test: Add tests for file-upload redeploy without flags scenarios

Author: Chhavi-Mandowara

src/adapters/file-upload.ts

@@ -14,7 +14,8 @@ import { print } from '../util';
 import BaseClass from './base-class';
 import { getFileList } from '../util/fs';
 import { createSignedUploadUrlMutation, importProjectMutation } from '../graphql';
-import { SignedUploadUrlData } from '../types/launch';
+import { SignedUploadUrlData, FileUploadMethod } from '../types/launch';
+import config from '../config';
 
 export default class FileUpload extends BaseClass {
   /**
@@ -40,6 +41,19 @@ export default class FileUpload extends BaseClass {
     await this.initApolloClient();
 
     let redeployLatest = this.config['redeploy-latest'];
+    let redeployLastUpload = this.config['redeploy-last-upload'];
+
+    if (!redeployLatest && !redeployLastUpload) {
+      await this.confirmRedeployment();
+      const latestRedeploymentConfirmed = await this.confirmLatestRedeployment();
+      redeployLatest = latestRedeploymentConfirmed;
+      redeployLastUpload = !latestRedeploymentConfirmed;
+    }
+
+    if (redeployLastUpload && redeployLatest) {
+      this.log('redeploy-last-upload and redeploy-latest flags are not supported together.', 'error');
+      this.exit(1);
+    }
 
     let uploadUid;
     if (redeployLatest) {
@@ -52,6 +66,38 @@ export default class FileUpload extends BaseClass {
     await this.createNewDeployment(true, uploadUid);
   }
 
+  private async confirmRedeployment(): Promise<void> {
+    const redeploy = await cliux.inquire({
+      type: 'confirm',
+      name: 'deployLatestCommit',
+      message: 'Do you want to redeploy this existing Launch project?',
+    });
+    if (!redeploy) {
+      this.log('Project redeployment aborted.', 'info');
+      this.exit(1);
+    }
+  }
+
+  private async confirmLatestRedeployment(): Promise<boolean | void> {
+    const choices = [
+      ...map(config.supportedFileUploadMethods, (fileUploadMethod) => ({
+        value: fileUploadMethod,
+        name: `Redeploy with ${fileUploadMethod}`,
+      }))
+    ];
+
+    const selectedFileUploadMethod: FileUploadMethod = await cliux.inquire({
+      choices: choices,
+      type: 'search-list',
+      name: 'fileUploadMethod',
+      message: 'Choose a redeploy method to proceed',
+    });
+    if (selectedFileUploadMethod === FileUploadMethod.LastFileUpload) {
+      return false;
+    }
+    return true;
+  }
+
   private async handleNewProject(): Promise<void> {
     const uploadUid = await this.prepareAndUploadNewProjectFile();
     await this.createNewProject(uploadUid);

src/adapters/github.ts

@@ -35,17 +35,35 @@ export default class GitHub extends BaseClass {
 
   private async handleExistingProject(): Promise<void> {
     await this.initApolloClient();
+
     const redeployLastUpload = this.config['redeploy-last-upload'];
+    const redeployLatest = this.config['redeploy-latest'];
 
     if (redeployLastUpload) {
       this.log('redeploy-last-upload flag is not supported for Github Project.', 'error');
       this.exit(1);
       return;
     }
 
+    if(!redeployLatest && !redeployLastUpload){
+      await this.confirmLatestRedeployment();
+    }
+
     await this.createNewDeployment();
   }
 
+  private async confirmLatestRedeployment(): Promise<void> {
+    const deployLatestCommit = (await ux.inquire({
+      type: 'confirm',
+      name: 'deployLatestCommit',
+      message: 'Redeploy latest commit?',
+    }));
+    if (!deployLatestCommit) {
+      this.log('Cannot create a new project because its an existing project.', 'info');
+      this.exit(1);
+    }
+  }
+
   private async handleNewProject(): Promise<void> {
     // NOTE Step 1: Check is Github connected
     if (await this.checkGitHubConnected()) {
@@ -59,6 +77,22 @@ export default class GitHub extends BaseClass {
     }
     await this.createNewProject();
   }
+  // private async handleNewProject(): Promise<void> {
+  //   // NOTE Step 1: Check is Github connected
+  //   // NOTE Step 2: check is the git remote available in the user's repo list
+  //   // NOTE Step 3: check is the user has proper git access
+  //   const isGithubConnected = await this.checkGitHubConnected();
+  //   console.log('thor1--------------git connected', isGithubConnected);
+  //   const isGitRemoteAvailableAndValid = await this.checkGitRemoteAvailableAndValid();
+  //   console.log('thor2--------------git remote available', isGitRemoteAvailableAndValid);
+  //   const isUserGitHubAccess = await this.checkUserGitHubAccess();
+  //   console.log('thor6--------------git user access', isUserGitHubAccess);
+  
+  //   if(isGithubConnected && isGitRemoteAvailableAndValid && isUserGitHubAccess){
+  //     await this.prepareForNewProjectCreation();
+  //   } 
+  //   await this.createNewProject();
+  // }
 
   /**
    * @method createNewProject - Create new launch project
@@ -241,7 +275,7 @@ export default class GitHub extends BaseClass {
       this.log('GitHub connection not found!', 'warn');
       await this.connectToAdapterOnUi();
     }
-
+console.log('thor5--------------git connected');
     return this.config.userConnection;
   }
 
@@ -272,7 +306,7 @@ export default class GitHub extends BaseClass {
       this.log('Repository not found in the list!', 'error');
       this.exit(1);
     }
-
+console.log('thor6--------------git remote available');
     return true;
   }
 

src/config/index.ts

@@ -40,7 +40,9 @@ const config = {
     'Import variables from the local env file',
   ],
   variableType: '',
-  supportedFrameworksForServerCommands: ['ANGULAR', 'OTHER', 'REMIX']
+  supportedFrameworksForServerCommands: ['ANGULAR', 'OTHER', 'REMIX'],
+  supportedFileUploadMethods: ['last file upload', 'new file']
+
 };
 
 export default config;

src/types/launch.ts

@@ -7,6 +7,11 @@ import { LoggerType } from './utils';
 
 type Providers = 'GitHub' | 'FileUpload';
 
+enum FileUploadMethod {
+  LastFileUpload = 'last file upload',
+  NewFile = 'new file',
+}
+
 type LogFn = (message: string | any, logType?: LoggerType | PrintOptions | undefined) => void;
 
 type ExitFn = (code?: number | undefined) => void;
@@ -38,6 +43,7 @@ type ConfigType = {
   deployment?: string;
   environment?: string;
   provider?: Providers;
+  fileUploadMethod?: FileUploadMethod;
   authorization?: string;
   logsApiBaseUrl: string;
   projectBasePath: string;
@@ -86,4 +92,5 @@ export {
   GraphqlHeaders,
   GraphqlApiClientInput,
   SignedUploadUrlData,
+  FileUploadMethod,
 };

test/unit/adapters/file-upload.test.ts

@@ -5,9 +5,9 @@ import { cliux } from '@contentstack/cli-utilities';
 import fs from 'fs';
 import { FileUpload, BaseClass } from '../../../src/adapters';
 import { BaseCommand } from '../../../src/base-command';
-import e from 'express';
 import { isNull } from 'util';
 import { log } from 'console';
+import { FileUploadMethod } from '../../../src/types/launch';
 
 describe('File Upload', () => {
   let inquireStub, exitStub, prepareApiClientsStub, prepareConfigStub, getConfigStub;
@@ -77,7 +77,23 @@ describe('File Upload', () => {
     });
 
     describe('Redeploy existing project', () => {
-      it('should run file upload flow for existing project where flag passed is redeploy-latest', async () => {
+      let sandbox;
+      let processExitStub;
+
+      beforeEach(() => {
+        sandbox = createSandbox();
+        
+        processExitStub = sandbox.stub(process, 'exit').callsFake((code) => {
+          throw new Error(code);
+        });
+      
+      });
+
+      afterEach(() => {
+        sandbox.restore();
+      });
+
+      it('should run file upload flow successfully for existing project where flag passed is redeploy-latest', async () => {
         let adapterConstructorOptions = {
           config: {
             isExistingProject: true,
@@ -98,7 +114,7 @@ describe('File Upload', () => {
         expect(showSuggestionStub.calledOnce).to.be.true;
       });
 
-      it('should run file upload flow for existing project where flag passed is redeploy-last-upload', async () => {
+      it('should run file upload flow successfully for existing project where flag passed is redeploy-last-upload', async () => {
         let adapterConstructorOptions = {
           config: {
             isExistingProject: true,
@@ -118,8 +134,126 @@ describe('File Upload', () => {
         expect(showDeploymentUrlStub.calledOnce).to.be.true;
         expect(showSuggestionStub.calledOnce).to.be.true;
       });
-    });
 
+      it('should exit with an error message when both --redeploy-last-upload and --redeploy-latest flags are passed', async () => {
+        let adapterConstructorOptions = {
+          config: {
+            isExistingProject: true,
+            currentConfig: { uid: '123244', organizationUid: 'bltxxxxxxxx' },
+            'redeploy-last-upload': true,
+            'redeploy-latest': true,
+          },
+        };
+        let exitStatusCode;
+
+        try {
+          await new FileUpload(adapterConstructorOptions).run();
+        } catch (err) {
+          exitStatusCode = err.message;
+        }
+
+        expect(processExitStub.calledOnceWithExactly(1)).to.be.true;
+        expect(exitStatusCode).to.equal('1');
+        expect(initApolloClientStub.calledOnce).to.be.true;
+        expect(createSignedUploadUrlStub.calledOnce).to.be.false;
+        expect(archiveStub.calledOnce).to.be.false;
+        expect(uploadFileStub.calledOnce).to.be.false;
+        expect(createNewDeploymentStub.calledOnce).to.be.false;
+        expect(prepareLaunchConfigStub.calledOnce).to.be.false;
+        expect(showLogsStub.calledOnce).to.be.false;
+        expect(showDeploymentUrlStub.calledOnce).to.be.false;
+        expect(showSuggestionStub.calledOnce).to.be.false;
+      });
+
+      it('should show prompt and successfully redeploy with "new file" if the option to redeploy with new file is selected, when --redeploy-latest and --redeploy-last-upload flags are not passed', async () => {
+        let adapterConstructorOptions = {
+          config: {
+            isExistingProject: true,
+            currentConfig: { uid: '123244', organizationUid: 'bltxxxxxxxx' },
+          },
+        };
+        inquireStub.withArgs({
+          type: 'confirm',
+          name: 'deployLatestCommit',
+          message: 'Do you want to redeploy this existing Launch project?',
+        }).resolves(true);
+        inquireStub.resolves(FileUploadMethod.NewFile);
+
+        await new FileUpload(adapterConstructorOptions).run();
+
+        expect(initApolloClientStub.calledOnce).to.be.true;
+        expect(createSignedUploadUrlStub.calledOnce).to.be.true;
+        expect(archiveStub.calledOnce).to.be.true;
+        expect(uploadFileStub.calledOnce).to.be.true;
+        expect(createNewDeploymentStub.calledOnce).to.be.true;
+        expect(prepareLaunchConfigStub.calledOnce).to.be.true;
+        expect(showLogsStub.calledOnce).to.be.true;
+        expect(showDeploymentUrlStub.calledOnce).to.be.true;
+        expect(showSuggestionStub.calledOnce).to.be.true;
+      });
+
+      it('should show prompt and successfully redeploy with "last file upload" if the option to redeploy with last file upload is selected, when --redeploy-latest and --redeploy-last-upload flags are not passed', async () => {
+        let adapterConstructorOptions = {
+          config: {
+            isExistingProject: true,
+            currentConfig: { uid: '123244', organizationUid: 'bltxxxxxxxx' },
+          },
+        };
+        inquireStub.withArgs({
+          type: 'confirm',
+          name: 'deployLatestCommit',
+          message: 'Do you want to redeploy this existing Launch project?',
+        }).resolves(true);
+        inquireStub.resolves(FileUploadMethod.LastFileUpload);
+
+        await new FileUpload(adapterConstructorOptions).run();
+
+        expect(initApolloClientStub.calledOnce).to.be.true;
+        expect(createSignedUploadUrlStub.calledOnce).to.be.false;
+        expect(archiveStub.calledOnce).to.be.false;
+        expect(uploadFileStub.calledOnce).to.be.false;
+        expect(createNewDeploymentStub.calledOnce).to.be.true;
+        expect(prepareLaunchConfigStub.calledOnce).to.be.true;
+        expect(showLogsStub.calledOnce).to.be.true;
+        expect(showDeploymentUrlStub.calledOnce).to.be.true;
+        expect(showSuggestionStub.calledOnce).to.be.true;
+      });
+
+      it('should exit if "No" is selected for prompt to redeploy, when --redeploy-latest and --redeploy-last-upload flags are not passed', async() => {
+        let adapterConstructorOptions = {
+          config: {
+            isExistingProject: true,
+            currentConfig: { uid: '123244', organizationUid: 'bltxxxxxxxx' },
+          },
+        };
+        inquireStub.withArgs({
+          type: 'confirm',
+          name: 'deployLatestCommit',
+          message: 'Do you want to redeploy this existing Launch project?',
+        }).resolves(false);
+        let exitStatusCode;
+
+        try {
+          await new FileUpload(adapterConstructorOptions).run();
+        } catch (err) {
+          exitStatusCode = err.message;
+        }
+
+        expect(processExitStub.calledOnceWithExactly(1)).to.be.true;
+        expect(exitStatusCode).to.equal('1');
+        expect(initApolloClientStub.calledOnce).to.be.true;
+        expect(createSignedUploadUrlStub.calledOnce).to.be.false;
+        expect(archiveStub.calledOnce).to.be.false;
+        expect(uploadFileStub.calledOnce).to.be.false;
+        expect(createNewDeploymentStub.calledOnce).to.be.false;
+        expect(prepareLaunchConfigStub.calledOnce).to.be.false;
+        expect(showLogsStub.calledOnce).to.be.false;
+        expect(showDeploymentUrlStub.calledOnce).to.be.false;
+        expect(showSuggestionStub.calledOnce).to.be.false;
+      });
+
+    });
+    
     describe('Deploy new project', () => {
       let adapterConstructorOptions = {
         config: {