@aws-cdk-testing/cli-integ 3.5.0 → 3.7.0

package/lib/xpmutex.ts

@@ -1,218 +0,0 @@
-import { watch, promises as fs, mkdirSync } from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-
-export class XpMutexPool {
-  public static fromDirectory(directory: string) {
-    mkdirSync(directory, { recursive: true });
-    return new XpMutexPool(directory);
-  }
-
-  public static fromName(name: string) {
-    return XpMutexPool.fromDirectory(path.join(os.tmpdir(), name));
-  }
-
-  private readonly waitingResolvers = new Set<() => void>();
-  private watcher: ReturnType<typeof watch> | undefined;
-
-  private constructor(public readonly directory: string) {
-    this.startWatch();
-  }
-
-  public mutex(name: string) {
-    return new XpMutex(this, name);
-  }
-
-  /**
-   * Await an unlock event
-   *
-   * (An unlock event is when a file in the directory gets deleted, with a tiny
-   * random sleep attached to it).
-   */
-  public awaitUnlock(maxWaitMs?: number): Promise<void> {
-    const wait = new Promise<void>(ok => {
-      this.waitingResolvers.add(async () => {
-        await randomSleep(10);
-        ok();
-      });
-    });
-
-    if (maxWaitMs) {
-      return Promise.race([wait, sleep(maxWaitMs)]);
-    } else {
-      return wait;
-    }
-  }
-
-  private startWatch() {
-    this.watcher = watch(this.directory);
-    (this.watcher as any).unref(); // @types doesn't know about this but it exists
-    this.watcher.on('change', async (eventType, fname) => {
-      // Only trigger on 'deletes'.
-      // After receiving the event, we check if the file exists.
-      // - If no: the file was deleted! Huzzah, this counts as a wakeup.
-      // - If yes: either the file was just created (in which case we don't need to wakeup)
-      //   or the event was due to a delete but someone raced us to it and claimed the
-      //   file already (in which case we also don't need to wake up).
-      if (eventType === 'rename' && !await fileExists(path.join(this.directory, fname.toString()))) {
-        this.notifyWaiters();
-      }
-    });
-    this.watcher.on('error', async (e) => {
-      // eslint-disable-next-line no-console
-      console.error(e);
-      await randomSleep(100);
-      this.startWatch();
-    });
-  }
-
-  private notifyWaiters() {
-    for (const promise of this.waitingResolvers) {
-      promise();
-    }
-    this.waitingResolvers.clear();
-  }
-}
-
-/**
- * Cross-process mutex
- *
- * Uses the presence of a file on disk and `fs.watch` to represent the mutex
- * and discover unlocks.
- */
-export class XpMutex {
-  private readonly fileName: string;
-
-  constructor(private readonly pool: XpMutexPool, public readonly mutexName: string) {
-    this.fileName = path.join(pool.directory, `${mutexName}.mutex`);
-  }
-
-  /**
-   * Try to acquire the lock (may fail)
-   */
-  public async tryAcquire(): Promise<ILock | undefined> {
-    while (true) {
-      // Acquire lock by being the one to create the file
-      try {
-        return await this.writePidFile('wx'); // Fails if the file already exists
-      } catch (e: any) {
-        if (e.code !== 'EEXIST') { throw e; }
-      }
-
-      // File already exists. Read the contents, see if it's an existent PID (if so, the lock is taken)
-      const ownerPid = await this.readPidFile();
-      if (ownerPid === undefined) {
-        // File got deleted just now, maybe we can acquire it again
-        continue;
-      }
-      if (processExists(ownerPid)) {
-        return undefined;
-      }
-
-      // If not, the lock is stale and will never be released anymore. We may
-      // delete it and acquire it anyway, but we may be racing someone else trying
-      // to do the same. Solve this as follows:
-      // - Try to acquire a lock that gives us permissions to declare the existing lock stale.
-      // - Sleep a small random period to reduce contention on this operation
-      await randomSleep(10);
-      const innerMux = new XpMutex(this.pool, `${this.mutexName}.${ownerPid}`);
-      const innerLock = await innerMux.tryAcquire();
-      if (!innerLock) {
-        return undefined;
-      }
-
-      // We may not release the 'inner lock' we used to acquire the rights to declare the other
-      // lock stale until we release the actual lock itself. If we did, other contenders might
-      // see it released while they're still in this fallback block and accidentally steal
-      // from a new legitimate owner.
-      return this.writePidFile('w', innerLock); // Force write lock file, attach inner lock as well
-    }
-  }
-
-  /**
-   * Acquire the lock, waiting until we can
-   */
-  public async acquire(): Promise<ILock> {
-    while (true) {
-      // Start the wait here, so we don't miss the signal if it comes after
-      // we try but before we sleep.
-      //
-      // We also periodically retry anyway since we may have missed the delete
-      // signal due to unfortunate timing.
-      const wait = this.pool.awaitUnlock(5000);
-
-      const lock = await this.tryAcquire();
-      if (lock) {
-        // Ignore the wait (count as handled)
-        wait.then(() => {}, () => {});
-        return lock;
-      }
-
-      await wait;
-      await randomSleep(100);
-    }
-  }
-
-  private async readPidFile(): Promise<number | undefined> {
-    const deadLine = Date.now() + 1000;
-    while (Date.now() < deadLine) {
-      let contents;
-      try {
-        contents = await fs.readFile(this.fileName, { encoding: 'utf-8' });
-      } catch (e: any) {
-        if (e.code === 'ENOENT') { return undefined; }
-        throw e;
-      }
-
-      // Retry until we've seen the full contents
-      if (contents.endsWith('.')) { return parseInt(contents.substring(0, contents.length - 1), 10); }
-      await sleep(10);
-    }
-
-    throw new Error(`${this.fileName} was never completely written`);
-  }
-
-  private async writePidFile(mode: string, additionalLock?: ILock): Promise<ILock> {
-    const fd = await fs.open(this.fileName, mode); // May fail if the file already exists
-    await fd.write(`${process.pid}.`); // Period guards against partial reads
-    await fd.close();
-
-    return {
-      release: async () => {
-        await fs.unlink(this.fileName);
-        await additionalLock?.release();
-      },
-    };
-  }
-}
-
-export interface ILock {
-  release(): Promise<void>;
-}
-
-async function fileExists(fileName: string) {
-  try {
-    await fs.stat(fileName);
-    return true;
-  } catch (e: any) {
-    if (e.code === 'ENOENT') { return false; }
-    throw e;
-  }
-}
-
-function processExists(pid: number) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise(ok => (setTimeout(ok, ms) as any).unref());
-}
-
-function randomSleep(ms: number) {
-  return sleep(Math.floor(Math.random() * ms));
-}

package/resources/cli-regression-patches/v2.130.0/node_modules/@aws-cdk-testing/cli-integ/resources/cdk-apps/sam_cdk_integ_app/lib/nested-stack.js

@@ -1,19 +0,0 @@
-if (process.env.PACKAGE_LAYOUT_VERSION === '1') {
-  var { NestedStack } = require('@aws-cdk/core');
-  var { Function, Runtime, Code } = require('@aws-cdk/aws-lambda');
-} else {
-  var { NestedStack } = require('aws-cdk-lib');
-  var { Function, Runtime, Code } = require('aws-cdk-lib/aws-lambda');
-}
-
-class NestedStack1 extends NestedStack {
-  constructor(scope, id, props) {
-    super(scope, id, props);
-    new Function(this, 'FunctionPythonRuntime', {
-      runtime: Runtime.PYTHON_3_12,
-      code: Code.fromAsset('./src/python/Function'),
-      handler: 'app.lambda_handler',
-    });
-  }
-}
-exports.NestedStack1 = NestedStack1;

package/resources/cli-regression-patches/v2.130.0/node_modules/@aws-cdk-testing/cli-integ/resources/cdk-apps/sam_cdk_integ_app/lib/test-stack.js

@@ -1,134 +0,0 @@
-var path = require('path');
-var { NestedStack1 } = require('./nested-stack');
-if (process.env.PACKAGE_LAYOUT_VERSION === '1') {
-  var { Stack } = require('@aws-cdk/core');
-  var { Runtime, LayerVersion, Code, Function, DockerImageFunction, DockerImageCode } = require('@aws-cdk/aws-lambda');
-  var { SpecRestApi, ApiDefinition } = require('@aws-cdk/aws-apigateway');
-  var { NodejsFunction } = require('@aws-cdk/aws-lambda-nodejs');
-  var { GoFunction } = require('@aws-cdk/aws-lambda-go');
-  var { PythonFunction, PythonLayerVersion } = require('@aws-cdk/aws-lambda-python');
-  var { Role, ServicePrincipal, PolicyStatement } = require('@aws-cdk/aws-iam');
-  var { RetentionDays } = require('@aws-cdk/aws-logs');
-} else {
-  var { Stack } = require('aws-cdk-lib');
-  var { Runtime, LayerVersion, Code, Function, DockerImageFunction, DockerImageCode } = require('aws-cdk-lib/aws-lambda');
-  var { SpecRestApi, ApiDefinition } = require('aws-cdk-lib/aws-apigateway');
-  var { NodejsFunction } = require('aws-cdk-lib/aws-lambda-nodejs');
-  var { GoFunction } = require('@aws-cdk/aws-lambda-go-alpha');
-  var { PythonFunction, PythonLayerVersion } = require('@aws-cdk/aws-lambda-python-alpha');
-  var { Role, ServicePrincipal, PolicyStatement } = require('aws-cdk-lib/aws-iam');
-  var { RetentionDays } = require('aws-cdk-lib/aws-logs');
-}
-
-const isRunningOnCodeBuild = !!process.env.CODEBUILD_BUILD_ID;
-
-class CDKSupportDemoRootStack extends Stack{
-  constructor(scope, id, props) {
-    super(scope, id, props);
-    // Python Runtime
-    // Layers
-    new PythonLayerVersion(this, 'PythonLayerVersion', {
-      compatibleRuntimes: [
-        Runtime.PYTHON_3_12,
-      ],
-      entry: './src/python/Layer',
-    });
-    new LayerVersion(this, 'LayerVersion', {
-      compatibleRuntimes: [
-        Runtime.PYTHON_3_12,
-      ],
-      code: Code.fromAsset('./src/python/Layer'),
-    });
-    new LayerVersion(this, 'BundledLayerVersionPythonRuntime', {
-      compatibleRuntimes: [
-        Runtime.PYTHON_3_12,
-      ],
-      code: Code.fromAsset('./src/python/Layer', {
-        bundling: {
-          command: [
-            '/bin/sh',
-            '-c',
-            'rm -rf /tmp/asset-input && mkdir /tmp/asset-input && cp * /tmp/asset-input && cd /tmp/asset-input && pip install -r requirements.txt -t . && mkdir /asset-output/python && cp -R /tmp/asset-input/* /asset-output/python',
-          ],
-          image: Runtime.PYTHON_3_12.bundlingImage,
-          user: 'root',
-        }
-      }),
-    });
-
-    // ZIP package type Functions
-    new PythonFunction(this, 'PythonFunction', {
-      entry: './src/python/Function',
-      index: 'app.py',
-      handler: 'lambda_handler',
-      runtime: Runtime.PYTHON_3_12,
-      functionName: 'pythonFunc',
-      logRetention: RetentionDays.THREE_MONTHS,
-    });
-    new Function(this, 'FunctionPythonRuntime', {
-      runtime: Runtime.PYTHON_3_12,
-      code: Code.fromAsset('./src/python/Function'),
-      handler: 'app.lambda_handler',
-    });
-    new Function(this, 'BundledFunctionPythonRuntime', {
-      runtime: Runtime.PYTHON_3_12,
-      code: Code.fromAsset('./src/python/Function/', {
-        bundling: {
-          command: [
-            '/bin/sh',
-            '-c',
-            'rm -rf /tmp/asset-input && mkdir /tmp/asset-input && cp * /tmp/asset-input && cd /tmp/asset-input && pip install -r requirements.txt -t . && cp -R /tmp/asset-input/* /asset-output',
-          ],
-          image: Runtime.PYTHON_3_12.bundlingImage,
-          user: 'root',
-        }
-      }),
-      handler: 'app.lambda_handler',
-    });
-
-    // NodeJs Runtime
-    new NodejsFunction(this, 'NodejsFunction', {
-      entry: path.join(__dirname, '../src/nodejs/NodeJsFunctionConstruct/app.ts'),
-      depsLockFilePath: path.join(__dirname, '../src/nodejs/NodeJsFunctionConstruct/package-lock.json'),
-      bundling: {
-        forceDockerBundling: true,
-      },
-      handler: 'lambdaHandler',
-    });
-
-    // Go Runtime
-    new GoFunction(this, 'GoFunction', {
-      entry: './src/go/GoFunctionConstruct',
-      bundling: {
-        forcedDockerBundling: true,
-        // Only use Google proxy in the CI tests, as it is blocked on workstations
-        goProxies: isRunningOnCodeBuild ? [GoFunction.GOOGLE_GOPROXY, 'direct'] : undefined,
-      },
-    });
-
-    // Image Package Type Functions
-    new DockerImageFunction(this, 'DockerImageFunction', {
-      code: DockerImageCode.fromImageAsset('./src/docker/DockerImageFunctionConstruct', {
-        file: 'Dockerfile',
-      }),
-    });
-
-    // Spec Rest Api
-    new SpecRestApi(this, 'SpecRestAPI', {
-      apiDefinition: ApiDefinition.fromAsset('./src/rest-api-definition.yaml'),
-    });
-    // Role to be used as credentials for the Spec rest APi
-    // it is used inside the spec rest api definition file
-    new Role(this, 'SpecRestApiRole', {
-      assumedBy: new ServicePrincipal('apigateway.amazonaws.com'),
-      roleName: 'SpecRestApiRole',
-    }).addToPolicy(new PolicyStatement({
-      actions: ['lambda:InvokeFunction'],
-      resources: ['*'],
-    }));
-
-    // Nested Stack
-    new NestedStack1(this, 'NestedStack', {});
-  }
-}
-exports.CDKSupportDemoRootStack = CDKSupportDemoRootStack;

package/tests/cli-integ-tests/cdk---exclusively-selects-only-selected-stack.integtest.ts

@@ -1,29 +0,0 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import { integTest, withDefaultFixture } from '../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest(
-  '--exclusively selects only selected stack',
-  withDefaultFixture(async (fixture) => {
-    // Deploy the "depends-on-failed" stack, with --exclusively. It will NOT fail (because
-    // of --exclusively) and it WILL create an output we can check for to confirm that it did
-    // get deployed.
-    const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json');
-    await fs.mkdir(path.dirname(outputsFile), { recursive: true });
-
-    await fixture.cdkDeploy('depends-on-failed', {
-      options: ['--exclusively', '--outputs-file', outputsFile],
-    });
-
-    // Verify the output to see that the stack deployed
-    const outputs = JSON.parse((await fs.readFile(outputsFile, { encoding: 'utf-8' })).toString());
-    expect(outputs).toEqual({
-      [`${fixture.stackNamePrefix}-depends-on-failed`]: {
-        TopicName: `${fixture.stackNamePrefix}-depends-on-failedMyTopic`,
-      },
-    });
-  }),
-);
-

package/tests/cli-integ-tests/cdk-assets/cdk-assets-uses-profile.integtest.ts

@@ -1,92 +0,0 @@
-
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import { integTest, withDefaultFixture } from '../../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest(`cdk-assets uses profile when specified`, withDefaultFixture(async (fixture) => {
-
-    const currentCreds = await fixture.aws.credentials();
-
-    await fixture.shell(['npm', 'init', '-y']);
-    await fixture.shell(['npm', 'install', `cdk-assets@latest`]);
-
-    const account = await fixture.aws.account();
-    const region = fixture.aws.region;
-    const bucketName = `cdk-hnb659fds-assets-${account}-${region}`;
-
-    // Write some asset files. Its important to have more than 1 because cdk-assets
-    // code has some funky state mutations that happens on each asset publishing.
-    const assetFile1 = 'testfile.txt';
-    const assetFile2 = 'testfile.txt';
-    await fs.writeFile(path.join(fixture.integTestDir, assetFile1), 'some asset file');
-    await fs.writeFile(path.join(fixture.integTestDir, assetFile2), 'some asset file');
-
-    // Write an asset JSON file to publish to the bootstrapped environment
-    const assetsJson = {
-      version: "38.0.1",
-      files: {
-        testfile1: {
-          source: {
-            path: assetFile1,
-            packaging: 'file',
-          },
-          destinations: {
-            current: {
-              region,
-              assumeRoleArn: `arn:\${AWS::Partition}:iam::${account}:role/cdk-hnb659fds-file-publishing-role-${account}-${region}`,
-              bucketName,
-              objectKey: `test-file1-${Date.now()}.json`,
-            }
-          }
-        },
-        testfile2: {
-          source: {
-            path: assetFile2,
-            packaging: 'file',
-          },
-          destinations: {
-            current: {
-              region,
-              assumeRoleArn: `arn:\${AWS::Partition}:iam::${account}:role/cdk-hnb659fds-file-publishing-role-${account}-${region}`,
-              bucketName,
-              objectKey: `test-file2-${Date.now()}.json`,
-            }
-          }
-        }
-      }
-    };
-
-    // create a profile with our current credentials.
-    //
-    // if you're wondering why can't we do the reverse (i.e write a bogus profile and assert a failure),
-    // its because when cdk-assets discovers the current account, it DOES consider the profile.
-    // writing a bogus profile would fail this operation and we won't be able to reach the code
-    // we're trying to test.
-    const credentialsFile = path.join(fixture.integTestDir, 'aws.credentials');
-    const profile = 'cdk-assets';
-
-    // this kind sucks but its what it is given we need to write a working profile
-    await fs.writeFile(credentialsFile, `[${profile}]
-aws_access_key_id=${currentCreds.accessKeyId}
-aws_secret_access_key=${currentCreds.secretAccessKey}
-aws_session_token=${currentCreds.sessionToken}`);
-
-    await fs.writeFile(path.join(fixture.integTestDir, 'assets.json'), JSON.stringify(assetsJson, undefined, 2));
-    await fixture.shell(['npx', 'cdk-assets', '--path', 'assets.json', 'publish', '--profile', profile], {
-      modEnv: {
-        ...fixture.cdkShellEnv(),
-        AWS_SHARED_CREDENTIALS_FILE: credentialsFile,
-
-        // remove the default creds so that if the command doesn't use
-        // the profile, it will fail with "Could not load credentials from any providers"
-        AWS_ACCESS_KEY_ID: '',
-        AWS_SECRET_ACCESS_KEY: '',
-        AWS_SESSION_TOKEN: ''
-
-      },
-    });
-
-  }),
-);

package/tests/cli-integ-tests/cdk-assets/smoketest.integtest.ts

@@ -1,82 +0,0 @@
-/**
- * Tests for the standalone cdk-assets executable, as used by CDK Pipelines
- */
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import { integTest, withDefaultFixture } from '../../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest(
-  `cdk-assets smoke test`,
-  withDefaultFixture(async (fixture) => {
-    await fixture.shell(['npm', 'init', '-y']);
-    await fixture.shell(['npm', 'install', `cdk-assets@latest`]);
-
-    const account = await fixture.aws.account();
-    const region = fixture.aws.region;
-    const bucketName = `cdk-hnb659fds-assets-${account}-${region}`;
-    const repositoryName = `cdk-hnb659fds-container-assets-${account}-${region}`;
-
-    const imageDir = 'imagedir';
-    await fs.mkdir(path.join(fixture.integTestDir, imageDir), { recursive: true });
-
-    // Write an asset file and a data file for the Docker image
-    const assetFile = 'testfile.txt';
-    for (const toCreate of [assetFile, `${imageDir}/datafile.txt`]) {
-      await fs.writeFile(path.join(fixture.integTestDir, toCreate), 'some asset file');
-    }
-
-    // Write a Dockerfile for the image build with a data file in it
-    await fs.writeFile(path.join(fixture.integTestDir, imageDir, 'Dockerfile'), [
-      'FROM scratch',
-      'ADD datafile.txt datafile.txt',
-    ].join('\n'));
-
-    // Write an asset JSON file to publish to the bootstrapped environment
-    const assetsJson = {
-      version: "38.0.1",
-      files: {
-        testfile: {
-          source: {
-            path: assetFile,
-            packaging: 'file',
-          },
-          destinations: {
-            current: {
-              region,
-              assumeRoleArn: `arn:\${AWS::Partition}:iam::${account}:role/cdk-hnb659fds-file-publishing-role-${account}-${region}`,
-              bucketName,
-              objectKey: `test-file-${Date.now()}.json`,
-            }
-          }
-        }
-      },
-      dockerImages: {
-        testimage: {
-          source: {
-            directory: imageDir,
-          },
-          destinations: {
-            current: {
-              region,
-              assumeRoleArn: `arn:\${AWS::Partition}:iam::${account}:role/cdk-hnb659fds-image-publishing-role-${account}-${region}`,
-              repositoryName,
-              imageTag: `test-image`, // Not fresh on every run because we'll run out of tags too easily
-            },
-          },
-        },
-      }
-    };
-
-    await fs.writeFile(path.join(fixture.integTestDir, 'assets.json'), JSON.stringify(assetsJson, undefined, 2));
-    await fixture.shell(['npx', 'cdk-assets', '--path', 'assets.json', '--verbose', 'publish'], {
-      modEnv: {
-        ...fixture.cdkShellEnv(),
-        // This is necessary for cdk-assets v2, if the credentials are supplied via
-        // config file (which they are on the CodeBuild canaries).
-        AWS_SDK_LOAD_CONFIG: '1',
-      },
-    });
-  }),
-);

package/tests/cli-integ-tests/cdk-automatic-ordering-with-concurrency.integtest.ts

@@ -1,15 +0,0 @@
-import { integTest, withDefaultFixture } from '../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest(
-  'automatic ordering with concurrency',
-  withDefaultFixture(async (fixture) => {
-    // Deploy the consuming stack which will include the producing stack
-    await fixture.cdkDeploy('order-consuming', { options: ['--concurrency', '2'] });
-
-    // Destroy the providing stack which will include the consuming stack
-    await fixture.cdkDestroy('order-providing');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-automatic-ordering.integtest.ts

@@ -1,15 +0,0 @@
-import { integTest, withDefaultFixture } from '../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest(
-  'automatic ordering',
-  withDefaultFixture(async (fixture) => {
-    // Deploy the consuming stack which will include the producing stack
-    await fixture.cdkDeploy('order-consuming');
-
-    // Destroy the providing stack which will include the consuming stack
-    await fixture.cdkDestroy('order-providing');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-automatic-rollback-if-paused-and---no-rollback-is-removed-from-flags.integtest.ts

@@ -1,40 +0,0 @@
-import { integTest, withSpecificFixture } from '../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest(
-  'automatic rollback if paused and --no-rollback is removed from flags',
-  withSpecificFixture('rollback-test-app', async (fixture) => {
-    let phase = '1';
-
-    // Should succeed
-    await fixture.cdkDeploy('test-rollback', {
-      options: ['--no-rollback'],
-      modEnv: { PHASE: phase },
-      verbose: false,
-    });
-    try {
-      phase = '2a';
-
-      // Should fail
-      const deployOutput = await fixture.cdkDeploy('test-rollback', {
-        options: ['--no-rollback'],
-        modEnv: { PHASE: phase },
-        verbose: false,
-        allowErrExit: true,
-      });
-      expect(deployOutput).toContain('UPDATE_FAILED');
-
-      // Do a deployment removing --no-rollback: this will roll back first and then deploy normally
-      phase = '1';
-      await fixture.cdkDeploy('test-rollback', {
-        options: ['--force'],
-        modEnv: { PHASE: phase },
-        verbose: false,
-      });
-    } finally {
-      await fixture.cdkDestroy('test-rollback');
-    }
-  }),
-);
-