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

package/tests/cli-integ-tests/cdk-bootstrap-upgrade-legacy-bootstrap-stack-to-new-bootstrap-stack-while-in-use.integtest.ts

@@ -1,47 +0,0 @@
-import { integTest, withoutBootstrap, randomString } from '../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest('upgrade legacy bootstrap stack to new bootstrap stack while in use', withoutBootstrap(async (fixture) => {
-  const bootstrapStackName = fixture.bootstrapStackName;
-
-  const legacyBootstrapBucketName = `aws-cdk-bootstrap-integ-test-legacy-bckt-${randomString()}`;
-  const newBootstrapBucketName = `aws-cdk-bootstrap-integ-test-v2-bckt-${randomString()}`;
-  fixture.rememberToDeleteBucket(legacyBootstrapBucketName); // This one will leak
-  fixture.rememberToDeleteBucket(newBootstrapBucketName); // This one shouldn't leak if the test succeeds, but let's be safe in case it doesn't
-
-  // Legacy bootstrap
-  await fixture.cdkBootstrapLegacy({
-    toolkitStackName: bootstrapStackName,
-    bootstrapBucketName: legacyBootstrapBucketName,
-  });
-
-  // Deploy stack that uses file assets
-  await fixture.cdkDeploy('lambda', {
-    options: [
-      '--context', `bootstrapBucket=${legacyBootstrapBucketName}`,
-      '--context', 'legacySynth=true',
-      '--context', `@aws-cdk/core:bootstrapQualifier=${fixture.qualifier}`,
-      '--toolkit-stack-name', bootstrapStackName,
-    ],
-  });
-
-  // Upgrade bootstrap stack to "new" style
-  await fixture.cdkBootstrapModern({
-    toolkitStackName: bootstrapStackName,
-    bootstrapBucketName: newBootstrapBucketName,
-    cfnExecutionPolicy: 'arn:aws:iam::aws:policy/AdministratorAccess',
-  });
-
-  // (Force) deploy stack again
-  // --force to bypass the check which says that the template hasn't changed.
-  await fixture.cdkDeploy('lambda', {
-    options: [
-      '--context', `bootstrapBucket=${newBootstrapBucketName}`,
-      '--context', `@aws-cdk/core:bootstrapQualifier=${fixture.qualifier}`,
-      '--toolkit-stack-name', bootstrapStackName,
-      '--force',
-    ],
-  });
-}));
-

package/tests/cli-integ-tests/cdk-can-still-load-old-assemblies.integtest.ts

@@ -1,57 +0,0 @@
-import { promises as fs } from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { integTest, RESOURCES_DIR, shell, withDefaultFixture, cloneDirectory } from '../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest(
-  'can still load old assemblies',
-  withDefaultFixture(async (fixture) => {
-    const cxAsmDir = path.join(os.tmpdir(), 'cdk-integ-cx');
-
-    const testAssembliesDirectory = path.join(RESOURCES_DIR, 'cloud-assemblies');
-    for (const asmdir of await listChildDirs(testAssembliesDirectory)) {
-      fixture.log(`ASSEMBLY ${asmdir}`);
-      await cloneDirectory(asmdir, cxAsmDir);
-
-      // Some files in the asm directory that have a .js extension are
-      // actually treated as templates. Evaluate them using NodeJS.
-      const templates = await listChildren(cxAsmDir, (fullPath) => Promise.resolve(fullPath.endsWith('.js')));
-      for (const template of templates) {
-        const targetName = template.replace(/.js$/, '');
-        await shell([process.execPath, template, '>', targetName], {
-          cwd: cxAsmDir,
-          outputs: [fixture.output],
-          modEnv: {
-            TEST_ACCOUNT: await fixture.aws.account(),
-            TEST_REGION: fixture.aws.region,
-          },
-        });
-      }
-
-      // Use this directory as a Cloud Assembly
-      const output = await fixture.cdk(['--app', cxAsmDir, '-v', 'synth']);
-
-      // Assert that there was no providerError in CDK's stderr
-      // Because we rely on the app/framework to actually error in case the
-      // provider fails, we inspect the logs here.
-      expect(output).not.toContain('$providerError');
-    }
-  }),
-);
-
-async function listChildren(parent: string, pred: (x: string) => Promise<boolean>) {
-  const ret = new Array<string>();
-  for (const child of await fs.readdir(parent, { encoding: 'utf-8' })) {
-    const fullPath = path.join(parent, child.toString());
-    if (await pred(fullPath)) {
-      ret.push(fullPath);
-    }
-  }
-  return ret;
-}
-
-async function listChildDirs(parent: string) {
-  return listChildren(parent, async (fullPath: string) => (await fs.stat(fullPath)).isDirectory());
-}

package/tests/cli-integ-tests/cdk-cdk-diff---fail-on-multiple-stacks-exits-with-error-if-any-of-the-stacks-contains-a-diff.integtest.ts

@@ -1,22 +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(
-  'cdk diff --fail on multiple stacks exits with error if any of the stacks contains a diff',
-  withDefaultFixture(async (fixture) => {
-    // GIVEN
-    const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);
-    expect(diff1).toContain('AWS::SNS::Topic');
-
-    await fixture.cdkDeploy('test-2');
-    const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);
-    expect(diff2).toContain('There were no differences');
-
-    // WHEN / THEN
-    await expect(
-      fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')]),
-    ).rejects.toThrow('exited with error');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff---fail-with-multiple-stack-exits-with-if-any-of-the-stacks-contains-a-diff.integtest.ts

@@ -1,22 +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(
-  'cdk diff --fail with multiple stack exits with if any of the stacks contains a diff',
-  withDefaultFixture(async (fixture) => {
-    // GIVEN
-    await fixture.cdkDeploy('test-1');
-    const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);
-    expect(diff1).toContain('There were no differences');
-
-    const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);
-    expect(diff2).toContain('AWS::SNS::Topic');
-
-    // WHEN / THEN
-    await expect(
-      fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')]),
-    ).rejects.toThrow('exited with error');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff---quiet-does-not-print-there-were-no-differences-message-for-stacks-which-have-no-differences.integtest.ts

@@ -1,19 +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(
-  "cdk diff --quiet does not print 'There were no differences' message for stacks which have no differences",
-  withDefaultFixture(async (fixture) => {
-    // GIVEN
-    await fixture.cdkDeploy('test-1');
-
-    // WHEN
-    const diff = await fixture.cdk(['diff', '--quiet', fixture.fullStackName('test-1')]);
-
-    // THEN
-    expect(diff).not.toContain('Stack test-1');
-    expect(diff).not.toContain('There were no differences');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff---security-only---fail-exits-when-security-changes-are-present.integtest.ts

@@ -1,14 +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(
-  'cdk diff --security-only --fail exits when security changes are present',
-  withDefaultFixture(async (fixture) => {
-    const stackName = 'iam-test';
-    await expect(fixture.cdk(['diff', '--security-only', '--fail', fixture.fullStackName(stackName)])).rejects.toThrow(
-      'exited with error',
-    );
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff---security-only---fail-exits-when-security-diff-for-sso-access-control-config.integtest.ts

@@ -1,13 +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(
-  'cdk diff --security-only --fail exits when security diff for sso access control config',
-  withDefaultFixture(async (fixture) => {
-    await expect(
-      fixture.cdk(['diff', '--security-only', '--fail', fixture.fullStackName('sso-access-control')]),
-    ).rejects.toThrow('exited with error');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff---security-only---fail-exits-when-security-diff-for-sso-assignment.integtest.ts

@@ -1,13 +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(
-  'cdk diff --security-only --fail exits when security diff for sso-assignment',
-  withDefaultFixture(async (fixture) => {
-    await expect(
-      fixture.cdk(['diff', '--security-only', '--fail', fixture.fullStackName('sso-assignment')]),
-    ).rejects.toThrow('exited with error');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff---security-only---fail-exits-when-security-diff-for-sso-perm-set-with-managed-policy.integtest.ts

@@ -1,13 +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(
-  'cdk diff --security-only --fail exits when security diff for sso-perm-set-with-managed-policy',
-  withDefaultFixture(async (fixture) => {
-    await expect(
-      fixture.cdk(['diff', '--security-only', '--fail', fixture.fullStackName('sso-perm-set-with-managed-policy')]),
-    ).rejects.toThrow('exited with error');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff---security-only---fail-exits-when-security-diff-for-sso-perm-set-without-managed-policy.integtest.ts

@@ -1,13 +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(
-  'cdk diff --security-only --fail exits when security diff for sso-perm-set-without-managed-policy',
-  withDefaultFixture(async (fixture) => {
-    await expect(
-      fixture.cdk(['diff', '--security-only', '--fail', fixture.fullStackName('sso-perm-set-without-managed-policy')]),
-    ).rejects.toThrow('exited with error');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff---security-only-successfully-outputs-sso-access-control-information.integtest.ts

@@ -1,35 +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(
-  'cdk diff --security-only successfully outputs sso-access-control information',
-  withDefaultFixture(async (fixture) => {
-    const diff = await fixture.cdk(['diff', '--security-only', fixture.fullStackName('sso-access-control')]);
-    `┌───┬────────────────────────────────┬────────────────────────┬─────────────────────────────────┐
-   │   │ Resource                       │ InstanceArn            │ AccessControlAttributes         │
-   ├───┼────────────────────────────────┼────────────────────────┼─────────────────────────────────┤
-   │ + │\${instanceAccessControlConfig} │ arn:aws:test:testvalue │ Key: first, Values: [a]         │
-   │   │                                │                        │ Key: second, Values: [b]        │
-   │   │                                │                        │ Key: third, Values: [c]         │
-   │   │                                │                        │ Key: fourth, Values: [d]        │
-   │   │                                │                        │ Key: fifth, Values: [e]         │
-   │   │                                │                        │ Key: sixth, Values: [f]         │
-   └───┴────────────────────────────────┴────────────────────────┴─────────────────────────────────┘
-`;
-    expect(diff).toContain('Resource');
-    expect(diff).toContain('instanceAccessControlConfig');
-
-    expect(diff).toContain('InstanceArn');
-    expect(diff).toContain('arn:aws:sso:::instance/testvalue');
-
-    expect(diff).toContain('AccessControlAttributes');
-    expect(diff).toContain('Key: first, Values: [a]');
-    expect(diff).toContain('Key: second, Values: [b]');
-    expect(diff).toContain('Key: third, Values: [c]');
-    expect(diff).toContain('Key: fourth, Values: [d]');
-    expect(diff).toContain('Key: fifth, Values: [e]');
-    expect(diff).toContain('Key: sixth, Values: [f]');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff---security-only-successfully-outputs-sso-assignment-information.integtest.ts

@@ -1,37 +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(
-  'cdk diff --security-only successfully outputs sso-assignment information',
-  withDefaultFixture(async (fixture) => {
-    const diff = await fixture.cdk(['diff', '--security-only', fixture.fullStackName('sso-assignment')]);
-    `┌───┬───────────────┬──────────────────────────────────┬─────────────────────────┬──────────────────────────────┬───────────────┬──────────────┬─────────────┐
-   │   │ Resource      │ InstanceArn                      │ PermissionSetArn        │ PrincipalId                  │ PrincipalType │ TargetId     │ TargetType  │
-   ├───┼───────────────┼──────────────────────────────────┼─────────────────────────┼──────────────────────────────┼───────────────┼──────────────┼─────────────┤
-   │ + │\${assignment} │ arn:aws:sso:::instance/testvalue │ arn:aws:sso:::testvalue │ 11111111-2222-3333-4444-test │ USER          │ 111111111111 │ AWS_ACCOUNT │
-   └───┴───────────────┴──────────────────────────────────┴─────────────────────────┴──────────────────────────────┴───────────────┴──────────────┴─────────────┘
-`;
-    expect(diff).toContain('Resource');
-    expect(diff).toContain('assignment');
-
-    expect(diff).toContain('InstanceArn');
-    expect(diff).toContain('arn:aws:sso:::instance/testvalue');
-
-    expect(diff).toContain('PermissionSetArn');
-    expect(diff).toContain('arn:aws:sso:::testvalue');
-
-    expect(diff).toContain('PrincipalId');
-    expect(diff).toContain('11111111-2222-3333-4444-test');
-
-    expect(diff).toContain('PrincipalType');
-    expect(diff).toContain('USER');
-
-    expect(diff).toContain('TargetId');
-    expect(diff).toContain('111111111111');
-
-    expect(diff).toContain('TargetType');
-    expect(diff).toContain('AWS_ACCOUNT');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff---security-only-successfully-outputs-sso-permission-set-with-managed-policy-information.integtest.ts

@@ -1,35 +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(
-  'cdk diff --security-only successfully outputs sso-permission-set-with-managed-policy information',
-  withDefaultFixture(async (fixture) => {
-    const diff = await fixture.cdk([
-      'diff',
-      '--security-only',
-      fixture.fullStackName('sso-perm-set-with-managed-policy'),
-    ]);
-    `┌───┬──────────────────────────────────────────┬──────────────────────────────────┬────────────────────┬───────────────────────────────────────────────────────────────┬─────────────────────────────────┐
-   │   │ Resource                                 │ InstanceArn                      │ PermissionSet name │ PermissionsBoundary                                           │ CustomerManagedPolicyReferences │
-   ├───┼──────────────────────────────────────────┼──────────────────────────────────┼────────────────────┼───────────────────────────────────────────────────────────────┼─────────────────────────────────┤
-   │ + │\${permission-set-with-managed-policy}    │ arn:aws:sso:::instance/testvalue │ niceWork           │ ManagedPolicyArn: arn:aws:iam::aws:policy/AdministratorAccess │ Name: forSSO, Path:             │
-`;
-
-    expect(diff).toContain('Resource');
-    expect(diff).toContain('permission-set-with-managed-policy');
-
-    expect(diff).toContain('InstanceArn');
-    expect(diff).toContain('arn:aws:sso:::instance/testvalue');
-
-    expect(diff).toContain('PermissionSet name');
-    expect(diff).toContain('niceWork');
-
-    expect(diff).toContain('PermissionsBoundary');
-    expect(diff).toContain('ManagedPolicyArn: arn:aws:iam::aws:policy/AdministratorAccess');
-
-    expect(diff).toContain('CustomerManagedPolicyReferences');
-    expect(diff).toContain('Name: forSSO, Path:');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff---security-only-successfully-outputs-sso-permission-set-without-managed-policy-information.integtest.ts

@@ -1,37 +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(
-  'cdk diff --security-only successfully outputs sso-permission-set-without-managed-policy information',
-  withDefaultFixture(async (fixture) => {
-    const diff = await fixture.cdk([
-      'diff',
-      '--security-only',
-      fixture.fullStackName('sso-perm-set-without-managed-policy'),
-    ]);
-    `┌───┬──────────────────────────────────────────┬──────────────────────────────────┬────────────────────┬───────────────────────────────────┬─────────────────────────────────┐
-   │   │ Resource                                 │ InstanceArn                      │ PermissionSet name │ PermissionsBoundary               │ CustomerManagedPolicyReferences │
-   ├───┼──────────────────────────────────────────┼──────────────────────────────────┼────────────────────┼───────────────────────────────────┼─────────────────────────────────┤
-   │ + │\${permission-set-without-managed-policy} │ arn:aws:sso:::instance/testvalue │ testName           │ CustomerManagedPolicyReference: { │                                 │
-   │   │                                          │                                  │                    │   Name: why, Path: /how/          │                                 │
-   │   │                                          │                                  │                    │ }                                 │                                 │
-`;
-    expect(diff).toContain('Resource');
-    expect(diff).toContain('permission-set-without-managed-policy');
-
-    expect(diff).toContain('InstanceArn');
-    expect(diff).toContain('arn:aws:sso:::instance/testvalue');
-
-    expect(diff).toContain('PermissionSet name');
-    expect(diff).toContain('testName');
-
-    expect(diff).toContain('PermissionsBoundary');
-    expect(diff).toContain('CustomerManagedPolicyReference: {');
-    expect(diff).toContain('Name: why, Path: /how/');
-    expect(diff).toContain('}');
-
-    expect(diff).toContain('CustomerManagedPolicyReferences');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff-doesnt-show-resource-metadata-changes.integtest.ts

@@ -1,23 +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(
-  'cdk diff doesnt show resource metadata changes',
-  withDefaultFixture(async (fixture) => {
-    // GIVEN - small initial stack with default resource metadata
-    await fixture.cdkDeploy('metadata');
-
-    // WHEN - changing resource metadata value
-    const diff = await fixture.cdk(['diff', fixture.fullStackName('metadata')], {
-      verbose: true,
-      modEnv: {
-        INTEG_METADATA_VALUE: 'custom',
-      },
-    });
-
-    // Assert there are no changes
-    expect(diff).toContain('There were no differences');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff-shows-resource-metadata-changes-with---no-change-set.integtest.ts

@@ -1,23 +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(
-  'cdk diff shows resource metadata changes with --no-change-set',
-  withDefaultFixture(async (fixture) => {
-    // GIVEN - small initial stack with default resource metadata
-    await fixture.cdkDeploy('metadata');
-
-    // WHEN - changing resource metadata value
-    const diff = await fixture.cdk(['diff --no-change-set', fixture.fullStackName('metadata')], {
-      verbose: true,
-      modEnv: {
-        INTEG_METADATA_VALUE: 'custom',
-      },
-    });
-
-    // Assert there are changes
-    expect(diff).not.toContain('There were no differences');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff-with-large-changeset-and-custom-toolkit-stack-name-and-qualifier-does-not-fail.integtest.ts

@@ -1,39 +0,0 @@
-import { integTest, withoutBootstrap } from '../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest('cdk diff with large changeset and custom toolkit stack name and qualifier does not fail', withoutBootstrap(async (fixture) => {
-  // Bootstrapping with custom toolkit stack name and qualifier
-  const qualifier = fixture.qualifier;
-
-  const toolkitStackName = fixture.bootstrapStackName;
-  await fixture.cdkBootstrapModern({
-    verbose: true,
-    toolkitStackName: toolkitStackName,
-    qualifier: qualifier,
-  });
-
-  // Deploying small initial stack with only one IAM role
-  await fixture.cdkDeploy('iam-roles', {
-    modEnv: {
-      NUMBER_OF_ROLES: '1',
-    },
-    options: [
-      '--toolkit-stack-name', toolkitStackName,
-      '--context', `@aws-cdk/core:bootstrapQualifier=${qualifier}`,
-    ],
-  });
-
-  // WHEN - adding a role with a ton of metadata to create a large diff
-  const diff = await fixture.cdk(['diff', '--toolkit-stack-name', toolkitStackName, '--context', `@aws-cdk/core:bootstrapQualifier=${qualifier}`, fixture.fullStackName('iam-roles')], {
-    verbose: true,
-    modEnv: {
-      NUMBER_OF_ROLES: '2',
-    },
-  });
-
-  // Assert that the CLI assumes the file publishing role:
-  expect(diff).toMatch(/Assuming role .*file-publishing-role/);
-  expect(diff).toContain('success: Published');
-}));
-

package/tests/cli-integ-tests/cdk-cdk-diff-with-large-changeset-does-not-fail.integtest.ts

@@ -1,28 +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(
-  'cdk diff with large changeset does not fail',
-  withDefaultFixture(async (fixture) => {
-    // GIVEN - small initial stack with only one IAM role
-    await fixture.cdkDeploy('iam-roles', {
-      modEnv: {
-        NUMBER_OF_ROLES: '1',
-      },
-    });
-
-    // WHEN - adding an additional role with a ton of metadata to create a large diff
-    const diff = await fixture.cdk(['diff', fixture.fullStackName('iam-roles')], {
-      verbose: true,
-      modEnv: {
-        NUMBER_OF_ROLES: '2',
-      },
-    });
-
-    // Assert that the CLI assumes the file publishing role:
-    expect(diff).toMatch(/Assuming role .*file-publishing-role/);
-    expect(diff).toContain('success: Published');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-diff.integtest.ts

@@ -1,18 +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(
-  'cdk diff',
-  withDefaultFixture(async (fixture) => {
-    const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);
-    expect(diff1).toContain('AWS::SNS::Topic');
-
-    const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);
-    expect(diff2).toContain('AWS::SNS::Topic');
-
-    // We can make it fail by passing --fail
-    await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1')])).rejects.toThrow('exited with error');
-  }),
-);
-

package/tests/cli-integ-tests/cdk-cdk-ls---show-dependencies---json---long.integtest.ts

@@ -1,50 +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(
-  'cdk ls --show-dependencies --json --long',
-  withDefaultFixture(async (fixture) => {
-    const listing = await fixture.cdk(['ls --show-dependencies --json --long'], { captureStderr: false });
-
-    const expectedStacks = [
-      {
-        id: 'order-providing',
-        name: 'order-providing',
-        enviroment: {
-          account: 'unknown-account',
-          region: 'unknown-region',
-          name: 'aws://unknown-account/unknown-region',
-        },
-        dependencies: [],
-      },
-      {
-        id: 'order-consuming',
-        name: 'order-consuming',
-        enviroment: {
-          account: 'unknown-account',
-          region: 'unknown-region',
-          name: 'aws://unknown-account/unknown-region',
-        },
-        dependencies: [
-          {
-            id: 'order-providing',
-            dependencies: [],
-          },
-        ],
-      },
-    ];
-
-    for (const stack of expectedStacks) {
-      expect(listing).toContain(fixture.fullStackName(stack.id));
-      expect(listing).toContain(fixture.fullStackName(stack.name));
-      expect(listing).toContain(stack.enviroment.account);
-      expect(listing).toContain(stack.enviroment.name);
-      expect(listing).toContain(stack.enviroment.region);
-      for (const dependency of stack.dependencies) {
-        expect(listing).toContain(fixture.fullStackName(dependency.id));
-      }
-    }
-  }),
-);
-