tests and lint

Author: Akila Tennakoon

src/cfnEnvironments/CfnEnvironmentRequestType.ts

@@ -16,7 +16,7 @@ export type DeploymentConfig = {
     includeNestedStacks?: boolean;
     importExistingResources?: boolean;
     onStackFailure?: OnStackFailure;
-    deploymentMode?: DeploymentMode
+    deploymentMode?: DeploymentMode;
 };
 
 export type ParsedCfnEnvironmentFile = {

src/services/CfnService.ts

@@ -58,9 +58,9 @@ import {
     ChangeSetType,
 } from '@aws-sdk/client-cloudformation';
 import { WaiterConfiguration, WaiterResult } from '@smithy/util-waiter';
+import { DeploymentMode } from '../stacks/actions/StackActionRequestType';
 import { Count } from '../telemetry/TelemetryDecorator';
 import { AwsClient } from './AwsClient';
-import { DeploymentMode } from '../stacks/actions/StackActionRequestType';
 
 export class CfnService {
     public constructor(private readonly awsClient: AwsClient) {}

src/services/CfnServiceV2.ts

@@ -11,12 +11,11 @@ import {
     ResourceChangeDetail,
     ChangeSetType,
 } from '@aws-sdk/client-cloudformation';
+import { DeploymentMode } from '../stacks/actions/StackActionRequestType';
 import { Measure } from '../telemetry/TelemetryDecorator';
 import { CFN_CLIENT_PATH } from '../utils/ClientUtil';
 import { DynamicModuleLoader } from '../utils/DynamicModuleLoader';
 import { CfnService } from './CfnService';
-import { DeploymentMode } from '../stacks/actions/StackActionRequestType';
-import { LoggerFactory } from '../telemetry/LoggerFactory';
 
 export type ResourceTargetDefinitionV2 = ResourceTargetDefinition & {
     BeforeValueFrom?: string;

src/stacks/actions/StackActionOperations.ts

@@ -43,18 +43,19 @@ function logCleanupError(error: unknown, workflowId: string, changeSetName: stri
 
 export function computeEligibleDeploymentMode(
     changeSetType: ChangeSetType,
-    deploymentMode?: DeploymentMode | undefined,
-    resourcesToImport?: ResourceToImport[] | undefined,
-    includeNestedStacks?: boolean | undefined,
-    onStackFailure?: OnStackFailure | undefined,
+    deploymentMode?: DeploymentMode,
+    importExistingResources?: boolean,
+    resourcesToImport?: ResourceToImport[],
+    includeNestedStacks?: boolean,
+    onStackFailure?: OnStackFailure,
 ): DeploymentMode | undefined {
     if (!deploymentMode) {
         return undefined;
     }
 
     if (deploymentMode === DeploymentMode.REVERT_DRIFT) {
         // import is not supported
-        if (resourcesToImport && resourcesToImport.length > 0) {
+        if (importExistingResources || (resourcesToImport && resourcesToImport.length > 0)) {
             return undefined;
         }
 
@@ -68,8 +69,8 @@ export function computeEligibleDeploymentMode(
             return undefined;
         }
 
-        // rollback/delete is not supported
-        if (onStackFailure === OnStackFailure.DO_NOTHING) {
+        // only ROLLBACK is supported
+        if (onStackFailure && onStackFailure !== OnStackFailure.ROLLBACK) {
             return undefined;
         }
     }
@@ -118,6 +119,7 @@ export async function processChangeSet(
     const deploymentMode = computeEligibleDeploymentMode(
         changeSetType,
         params.deploymentMode,
+        params.importExistingResources,
         params.resourcesToImport,
         params.includeNestedStacks,
         params.onStackFailure,

tst/unit/stackActions/StackActionWorkflowOperations.test.ts

@@ -1,4 +1,4 @@
-import { Change, ChangeSetType, StackStatus } from '@aws-sdk/client-cloudformation';
+import { Change, ChangeSetType, StackStatus, OnStackFailure } from '@aws-sdk/client-cloudformation';
 import { WaiterState } from '@smithy/util-waiter';
 import { DateTime } from 'luxon';
 import { stubInterface } from 'ts-sinon';
@@ -18,12 +18,14 @@ import {
     parseValidationEvents,
     publishValidationDiagnostics,
     isStackInReview,
+    computeEligibleDeploymentMode,
 } from '../../../src/stacks/actions/StackActionOperations';
 import {
     CreateValidationParams,
     StackActionPhase,
     StackActionState,
     ValidationDetail,
+    DeploymentMode,
 } from '../../../src/stacks/actions/StackActionRequestType';
 import { StackActionWorkflowState } from '../../../src/stacks/actions/StackActionWorkflowType';
 import { ExtensionName } from '../../../src/utils/ExtensionConfig';
@@ -578,4 +580,63 @@ describe('StackActionWorkflowOperations', () => {
             expect(result).toBe(true);
         });
     });
+
+    describe('computeEligibleDeploymentMode', () => {
+        it('should return undefined when deploymentMode is not provided', () => {
+            const result = computeEligibleDeploymentMode(ChangeSetType.UPDATE, undefined);
+            expect(result).toBeUndefined();
+        });
+
+        it('should return deploymentMode when all conditions are met for REVERT_DRIFT', () => {
+            const result = computeEligibleDeploymentMode(
+                ChangeSetType.UPDATE,
+                DeploymentMode.REVERT_DRIFT,
+                false,
+                undefined,
+                false,
+                OnStackFailure.ROLLBACK,
+            );
+            expect(result).toBe(DeploymentMode.REVERT_DRIFT);
+        });
+
+        it('should return undefined when changeSetType is CREATE', () => {
+            const result = computeEligibleDeploymentMode(ChangeSetType.CREATE, DeploymentMode.REVERT_DRIFT);
+            expect(result).toBeUndefined();
+        });
+
+        it('should return undefined when importExistingResources is true', () => {
+            const result = computeEligibleDeploymentMode(ChangeSetType.UPDATE, DeploymentMode.REVERT_DRIFT, true);
+            expect(result).toBeUndefined();
+        });
+
+        it('should return undefined when resourcesToImport has items', () => {
+            const result = computeEligibleDeploymentMode(ChangeSetType.UPDATE, DeploymentMode.REVERT_DRIFT, false, [
+                { LogicalResourceId: 'test', ResourceType: 'AWS::S3::Bucket', ResourceIdentifier: {} },
+            ]);
+            expect(result).toBeUndefined();
+        });
+
+        it('should return undefined when includeNestedStacks is true', () => {
+            const result = computeEligibleDeploymentMode(
+                ChangeSetType.UPDATE,
+                DeploymentMode.REVERT_DRIFT,
+                false,
+                undefined,
+                true,
+            );
+            expect(result).toBeUndefined();
+        });
+
+        it('should return undefined when onStackFailure is DO_NOTHING', () => {
+            const result = computeEligibleDeploymentMode(
+                ChangeSetType.UPDATE,
+                DeploymentMode.REVERT_DRIFT,
+                false,
+                undefined,
+                false,
+                OnStackFailure.DO_NOTHING,
+            );
+            expect(result).toBeUndefined();
+        });
+    });
 });