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

package/tests/cli-integ-tests/cdk-test-resource-import-with-construct-that-requires-bundling.integtest.ts

@@ -1,74 +0,0 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import { DescribeStacksCommand, GetTemplateCommand } from '@aws-sdk/client-cloudformation';
-import { integTest, withDefaultFixture } from '../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest(
-  'test resource import with construct that requires bundling',
-  withDefaultFixture(async (fixture) => {
-    // GIVEN
-    const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json');
-    await fs.mkdir(path.dirname(outputsFile), { recursive: true });
-
-    // First, create a stack that includes a NodeJSFunction lambda and one bucket that will be removed from the stack but NOT deleted from AWS.
-    await fixture.cdkDeploy('importable-stack', {
-      modEnv: { INCLUDE_NODEJS_FUNCTION_LAMBDA: '1', INCLUDE_SINGLE_BUCKET: '1', RETAIN_SINGLE_BUCKET: '1' },
-      options: ['--outputs-file', outputsFile],
-    });
-
-    try {
-      // Second, now the bucket we will remove is in the stack and has a logicalId. We can now make the resource mapping file.
-      // This resource mapping file will be used to tell the import operation what bucket to bring into the stack.
-      const fullStackName = fixture.fullStackName('importable-stack');
-      const outputs = JSON.parse((await fs.readFile(outputsFile, { encoding: 'utf-8' })).toString());
-      const bucketLogicalId = outputs[fullStackName].BucketLogicalId;
-      const bucketName = outputs[fullStackName].BucketName;
-      const bucketResourceMap = {
-        [bucketLogicalId]: {
-          BucketName: bucketName,
-        },
-      };
-      const mappingFile = path.join(fixture.integTestDir, 'outputs', 'mapping.json');
-      await fs.writeFile(mappingFile, JSON.stringify(bucketResourceMap), { encoding: 'utf-8' });
-
-      // Third, remove the bucket from the stack, but don't delete the bucket from AWS.
-      await fixture.cdkDeploy('importable-stack', {
-        modEnv: { INCLUDE_NODEJS_FUNCTION_LAMBDA: '1', INCLUDE_SINGLE_BUCKET: '0', RETAIN_SINGLE_BUCKET: '0' },
-      });
-      const cfnTemplateBeforeImport = await fixture.aws.cloudFormation.send(
-        new GetTemplateCommand({ StackName: fullStackName }),
-      );
-      expect(cfnTemplateBeforeImport.TemplateBody).not.toContain(bucketLogicalId);
-
-      // WHEN
-      await fixture.cdk(['import', '--resource-mapping', mappingFile, fixture.fullStackName('importable-stack')], {
-        modEnv: { INCLUDE_NODEJS_FUNCTION_LAMBDA: '1', INCLUDE_SINGLE_BUCKET: '1', RETAIN_SINGLE_BUCKET: '0' },
-      });
-
-      // THEN
-      const describeStacksResponse = await fixture.aws.cloudFormation.send(
-        new DescribeStacksCommand({ StackName: fullStackName }),
-      );
-      const cfnTemplateAfterImport = await fixture.aws.cloudFormation.send(
-        new GetTemplateCommand({ StackName: fullStackName }),
-      );
-
-      // If bundling is skipped during import for NodeJSFunction lambda, then the operation should fail and exit
-      expect(describeStacksResponse.Stacks![0].StackStatus).toEqual('IMPORT_COMPLETE');
-
-      // If the import operation is successful, the template should contain the imported bucket
-      expect(cfnTemplateAfterImport.TemplateBody).toContain(bucketLogicalId);
-    } finally {
-      // Clean up the resources we created
-      await fixture.cdkDestroy('importable-stack');
-    }
-  }),
-);
-
-/**
- * Create a queue, orphan that queue, then import the queue.
- *
- * We want to test with a large template to make sure large templates can work with import.
- */

package/tests/cli-integ-tests/cdk-test-resource-import.integtest.ts

@@ -1,64 +0,0 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import { DescribeStacksCommand, GetTemplateCommand } from '@aws-sdk/client-cloudformation';
-import { integTest, withDefaultFixture, randomString } from '../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest(
-  'test resource import',
-  withDefaultFixture(async (fixture) => {
-    // GIVEN
-    const randomPrefix = randomString();
-    const uniqueOutputsFileName = `${randomPrefix}Outputs.json`; // other tests use the outputs file. Make sure we don't collide.
-    const outputsFile = path.join(fixture.integTestDir, 'outputs', uniqueOutputsFileName);
-    await fs.mkdir(path.dirname(outputsFile), { recursive: true });
-
-    // First, create a stack that includes many queues, and one queue that will be removed from the stack but NOT deleted from AWS.
-    await fixture.cdkDeploy('importable-stack', {
-      modEnv: { LARGE_TEMPLATE: '1', INCLUDE_SINGLE_QUEUE: '1', RETAIN_SINGLE_QUEUE: '1' },
-      options: ['--outputs-file', outputsFile],
-    });
-
-    try {
-      // Second, now the queue we will remove is in the stack and has a logicalId. We can now make the resource mapping file.
-      // This resource mapping file will be used to tell the import operation what queue to bring into the stack.
-      const fullStackName = fixture.fullStackName('importable-stack');
-      const outputs = JSON.parse((await fs.readFile(outputsFile, { encoding: 'utf-8' })).toString());
-      const queueLogicalId = outputs[fullStackName].QueueLogicalId;
-      const queueResourceMap = {
-        [queueLogicalId]: { QueueUrl: outputs[fullStackName].QueueUrl },
-      };
-      const mappingFile = path.join(fixture.integTestDir, 'outputs', `${randomPrefix}Mapping.json`);
-      await fs.writeFile(mappingFile, JSON.stringify(queueResourceMap), { encoding: 'utf-8' });
-
-      // Third, remove the queue from the stack, but don't delete the queue from AWS.
-      await fixture.cdkDeploy('importable-stack', {
-        modEnv: { LARGE_TEMPLATE: '1', INCLUDE_SINGLE_QUEUE: '0', RETAIN_SINGLE_QUEUE: '0' },
-      });
-      const cfnTemplateBeforeImport = await fixture.aws.cloudFormation.send(
-        new GetTemplateCommand({ StackName: fullStackName }),
-      );
-      expect(cfnTemplateBeforeImport.TemplateBody).not.toContain(queueLogicalId);
-
-      // WHEN
-      await fixture.cdk(['import', '--resource-mapping', mappingFile, fixture.fullStackName('importable-stack')], {
-        modEnv: { LARGE_TEMPLATE: '1', INCLUDE_SINGLE_QUEUE: '1', RETAIN_SINGLE_QUEUE: '0' },
-      });
-
-      // THEN
-      const describeStacksResponse = await fixture.aws.cloudFormation.send(
-        new DescribeStacksCommand({ StackName: fullStackName }),
-      );
-      const cfnTemplateAfterImport = await fixture.aws.cloudFormation.send(
-        new GetTemplateCommand({ StackName: fullStackName }),
-      );
-      expect(describeStacksResponse.Stacks![0].StackStatus).toEqual('IMPORT_COMPLETE');
-      expect(cfnTemplateAfterImport.TemplateBody).toContain(queueLogicalId);
-    } finally {
-      // Clean up
-      await fixture.cdkDestroy('importable-stack');
-    }
-  }),
-);
-

package/tests/cli-integ-tests/cdk-two-ways-of-showing-the-version.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(
-  'Two ways of showing the version',
-  withDefaultFixture(async (fixture) => {
-    const version1 = await fixture.cdk(['version'], { verbose: false });
-    const version2 = await fixture.cdk(['--version'], { verbose: false });
-
-    expect(version1).toEqual(version2);
-  }),
-);
-

package/tests/cli-integ-tests/cdk-update-to-stack-in-rollback_complete-state-will-delete-stack-and-create-a-new-one.integtest.ts

@@ -1,47 +0,0 @@
-import { DescribeStacksCommand } from '@aws-sdk/client-cloudformation';
-import { integTest, withDefaultFixture } from '../../lib';
-
-jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
-
-integTest(
-  'update to stack in ROLLBACK_COMPLETE state will delete stack and create a new one',
-  withDefaultFixture(async (fixture) => {
-    // GIVEN
-    await expect(
-      fixture.cdkDeploy('param-test-1', {
-        options: ['--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`],
-        captureStderr: false,
-      }),
-    ).rejects.toThrow('exited with error');
-
-    const response = await fixture.aws.cloudFormation.send(
-      new DescribeStacksCommand({
-        StackName: fixture.fullStackName('param-test-1'),
-      }),
-    );
-
-    const stackArn = response.Stacks?.[0].StackId;
-    expect(response.Stacks?.[0].StackStatus).toEqual('ROLLBACK_COMPLETE');
-
-    // WHEN
-    const newStackArn = await fixture.cdkDeploy('param-test-1', {
-      options: ['--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`],
-      captureStderr: false,
-    });
-
-    const newStackResponse = await fixture.aws.cloudFormation.send(
-      new DescribeStacksCommand({
-        StackName: newStackArn,
-      }),
-    );
-
-    // THEN
-    expect(stackArn).not.toEqual(newStackArn); // new stack was created
-    expect(newStackResponse.Stacks?.[0].StackStatus).toEqual('CREATE_COMPLETE');
-    expect(newStackResponse.Stacks?.[0].Parameters).toContainEqual({
-      ParameterKey: 'TopicNameParam',
-      ParameterValue: `${fixture.stackNamePrefix}allgood`,
-    });
-  }),
-);
-

package/tests/cli-integ-tests/cdk-vpc-lookup.integtest.ts

@@ -1,26 +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(
-  'VPC Lookup',
-  withDefaultFixture(async (fixture) => {
-    fixture.log('Making sure we are clean before starting.');
-    await fixture.cdkDestroy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } });
-
-    fixture.log('Setting up: creating a VPC with known tags');
-    await fixture.cdkDeploy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } });
-    fixture.log('Setup complete!');
-
-    fixture.log('Verifying we can now import that VPC');
-    await fixture.cdkDeploy('import-vpc', { modEnv: { ENABLE_VPC_TESTING: 'IMPORT' } });
-  }),
-);
-
-// testing a construct with a builtin Nodejs Lambda Function.
-// In this case we are testing the s3.Bucket construct with the
-// autoDeleteObjects prop set to true, which creates a Lambda backed
-// CustomResource. Since the compiled Lambda code (e.g. __entrypoint__.js)
-// is bundled as part of the CDK package, we want to make sure we don't
-// introduce changes to the compiled code that could prevent the Lambda from
-// executing. If we do, this test will timeout and fail.

package/tests/cli-integ-tests/proxy.integtest.ts

@@ -1,168 +0,0 @@
-import { promises as fs } from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { integTest } from '../../lib/integ-test';
-import { startProxyServer } from '../../lib/proxy';
-import { TestFixture, withDefaultFixture } from '../../lib/with-cdk-app';
-
-const docker = process.env.CDK_DOCKER ?? 'docker';
-
-integTest(
-  'all calls from isolated container go through proxy',
-  withDefaultFixture(async (fixture) => {
-    // Find the 'cdk' command and make sure it is mounted into the container
-    const cdkFullpath = (await fixture.shell(['which', 'cdk'])).trim();
-    let cdkTop = findMountableParent(cdkFullpath);
-
-    // Run a 'cdk deploy' inside the container
-    const commands = [
-      `env ${renderEnv(fixture.cdkShellEnv())} ${cdkFullpath} ${fixture.cdkDeployCommandLine('test-2').join(' ')} -v`,
-    ];
-
-    await runInIsolatedContainer(fixture, [cdkTop], commands);
-  }),
-);
-
-async function runInIsolatedContainer(fixture: TestFixture, pathsToMount: string[], testCommands: string[]) {
-  pathsToMount.push(
-    `${process.env.HOME}`,
-    fixture.integTestDir,
-  );
-
-  // Resolve credential provider to an access key that we can pass into the container
-  const credentials = await fixture.aws.credentials();
-
-  const proxy = await startProxyServer(fixture.integTestDir);
-  try {
-    const proxyPort = proxy.port;
-
-    const setupCommands = [
-      'apt-get update -qq',
-      'apt-get install -qqy nodejs > /dev/null',
-      ...isolatedDockerCommands(proxyPort, proxy.certPath),
-    ];
-
-    const scriptName = path.join(fixture.integTestDir, 'script.sh');
-
-    // Write a script file
-    await fs.writeFile(scriptName, [
-      '#!/bin/bash',
-      'set -x',
-      'set -eu',
-      ...setupCommands,
-      ...testCommands,
-    ].join('\n'), 'utf-8');
-
-    await fs.chmod(scriptName, 0o755);
-
-    await fixture.ecrPublicLogin();
-
-    // Run commands in a Docker shell
-    await fixture.shell([
-      docker, 'run', '--net=bridge', '--rm',
-      ...pathsToMount.flatMap(p => ['-v', `${p}:${p}`]),
-      ...['HOME', 'AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_SESSION_TOKEN'].flatMap(e => ['-e', e]),
-      '-w', fixture.integTestDir,
-      '--cap-add=NET_ADMIN',
-      'public.ecr.aws/ubuntu/ubuntu:24.04_stable',
-      `${scriptName}`,
-    ], {
-      modEnv: {
-        AWS_ACCESS_KEY_ID: credentials.accessKeyId,
-        AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
-        AWS_SESSION_TOKEN: credentials.sessionToken,
-      },
-    });
-  } finally {
-    await proxy.stop();
-  }
-}
-
-/**
- * Return the commands necessary to isolate the inside of the container from the internet,
- * except by going through the proxy
- */
-function isolatedDockerCommands(proxyPort: number, caBundlePath: string) {
-  let defaultBridgeIp = '172.17.0.1';
-
-  // The host's default IP is different on CodeBuild than it is on other Docker systems.
-  if (process.env.CODEBUILD_BUILD_ARN) {
-    defaultBridgeIp = '172.18.0.1';
-  }
-
-  return [
-    'echo Working...',
-    'apt-get install -qqy curl net-tools iputils-ping dnsutils iptables > /dev/null',
-    '',
-    // Looking up `host.docker.internal` is necessary on MacOS Finch and Docker Desktop
-    // on Mac. The magic IP address is necessary on CodeBuild and GitHub Actions.
-    //
-    // I tried `--add-host=host.docker.internal:host-gateway` on the Linuxes but
-    // it doesn't change anything on either GHA or CodeBuild, so we're left with this
-    // backup solution.
-    'gateway=$(dig +short host.docker.internal)',
-    'if [[ -z "$gateway" ]]; then',
-    `  gateway=${defaultBridgeIp}`,
-    'fi',
-    '',
-    '# Some iptables manipulation; there might be unnecessary commands in here, not an expert',
-    'iptables -F',
-    'iptables -X',
-    'iptables -P INPUT DROP',
-    'iptables -P OUTPUT DROP',
-    'iptables -P FORWARD DROP',
-    'iptables -A INPUT -i lo -j ACCEPT',
-    'iptables -A OUTPUT -o lo -j ACCEPT',
-    'iptables -A OUTPUT -d $gateway -j ACCEPT',
-    'iptables -A INPUT -s $gateway -j ACCEPT',
-    '',
-    '',
-    `if [[ ! -f ${caBundlePath} ]]; then`,
-    `    echo "Could not find ${caBundlePath}, this will probably not go well. Exiting." >&2`,
-    '    exit 1',
-    'fi',
-    '',
-    '# Configure a bunch of tools to work with the proxy',
-    'echo "+-------------------------------------------------------------------------------------+"',
-    'echo "|  Direct network traffic has been blocked, everything must go through the proxy.     |"',
-    'echo "+-------------------------------------------------------------------------------------+"',
-    `export HTTP_PROXY=http://$gateway:${proxyPort}/`,
-    `export HTTPS_PROXY=http://$gateway:${proxyPort}/`,
-    `export NODE_EXTRA_CA_CERTS=${caBundlePath}`,
-    `export AWS_CA_BUNDLE=${caBundlePath}`,
-    `export SSL_CERT_FILE=${caBundlePath}`,
-    'echo "Acquire::http::proxy \"$HTTP_PROXY\";" >> /etc/apt/apt.conf.d/95proxies',
-    'echo "Acquire::https::proxy \"$HTTPS_PROXY\";" >> /etc/apt/apt.conf.d/95proxies',
-  ];
-}
-
-function renderEnv(env: Record<string, string | undefined>) {
-  return Object.entries(env).filter(([_, v]) => v).map(([k, v]) => `${k}='${v}'`).join(' ');
-}
-
-/**
- * Find a broadly mountable parent of the given directory
- *
- * We don't want to just mount the top-level directory, because
- * it could end up being `/var` (top-level dir of tmpdir on Mac).
- */
-function findMountableParent(dir: string): string {
-  const candidates = [
-    os.tmpdir(),
-    process.env.TMPDIR,
-    process.env.HOME,
-  ];
-  for (const cand of candidates) {
-    if (cand === undefined) {
-      continue;
-    }
-
-    if (dir.startsWith(cand)) {
-      const suffix = dir.substring(cand.length);
-      const firstChildDir = suffix.split('/')[0];
-
-      return path.join(cand, firstChildDir);
-    }
-  }
-  return dir;
-}

package/tests/init-csharp/init-csharp.integtest.ts

@@ -1,15 +0,0 @@
-import { integTest, withTemporaryDirectory, ShellHelper, withPackages } from '../../lib';
-
-['app', 'sample-app'].forEach(template => {
-  integTest(`init C♯ ${template}`, withTemporaryDirectory(withPackages(async (context) => {
-    context.packages.assertJsiiPackagesAvailable();
-
-    const shell = ShellHelper.fromContext(context);
-    await context.packages.makeCliAvailable();
-
-    await shell.shell(['cdk', 'init', '-l', 'csharp', template]);
-    await context.packages.initializeDotnetPackages(context.integTestDir);
-    await shell.shell(['cdk', 'synth']);
-  })));
-});
-

package/tests/init-fsharp/init-fsharp.integtest.ts

@@ -1,15 +0,0 @@
-import { integTest, withTemporaryDirectory, ShellHelper, withPackages } from '../../lib';
-
-['app', 'sample-app'].forEach(template => {
-  integTest(`init F♯ ${template}`, withTemporaryDirectory(withPackages(async (context) => {
-    context.packages.assertJsiiPackagesAvailable();
-
-    const shell = ShellHelper.fromContext(context);
-    await context.packages.makeCliAvailable();
-
-    await shell.shell(['cdk', 'init', '-l', 'fsharp', template]);
-    await context.packages.initializeDotnetPackages(context.integTestDir);
-    await shell.shell(['cdk', 'synth']);
-  })));
-});
-

package/tests/init-go/init-go.integtest.ts

@@ -1,28 +0,0 @@
-import { integTest, withTemporaryDirectory, ShellHelper, withPackages } from '../../lib';
-
-['app', 'sample-app'].forEach(template => {
-  integTest(`init go ${template}`, withTemporaryDirectory(withPackages(async (context) => {
-    const isCanary = !!process.env.IS_CANARY;
-    context.packages.assertJsiiPackagesAvailable();
-
-    const shell = ShellHelper.fromContext(context);
-    await context.packages.makeCliAvailable();
-
-    await shell.shell(['cdk', 'init', '-l', 'go', template]);
-
-    // Canaries will use the generated go.mod as is
-    // For pipeline tests we replace the source with the locally build one
-    if (!isCanary) {
-      const dir = process.env.CODEBUILD_SRC_DIR ?? process.env.GITHUB_WORKSPACE;
-      if (!dir) {
-        throw new Error('Cannot figure out CI system root directory');
-      }
-
-      await shell.shell(['go', 'mod', 'edit', '-replace', `github.com/aws/aws-cdk-go/awscdk/v2=${dir}/go/awscdk`]);
-    }
-
-    await shell.shell(['go', 'mod', 'tidy']);
-    await shell.shell(['go', 'test']);
-    await shell.shell(['cdk', 'synth']);
-  })));
-});

package/tests/init-java/init-java.integtest.ts

@@ -1,14 +0,0 @@
-import { integTest, withTemporaryDirectory, ShellHelper, withPackages } from '../../lib';
-
-['app', 'sample-app'].forEach(template => {
-  integTest(`init java ${template}`, withTemporaryDirectory(withPackages(async (context) => {
-    context.packages.assertJsiiPackagesAvailable();
-
-    const shell = ShellHelper.fromContext(context);
-    await context.packages.makeCliAvailable();
-
-    await shell.shell(['cdk', 'init', '-l', 'java', template]);
-    await shell.shell(['mvn', 'package']);
-    await shell.shell(['cdk', 'synth']);
-  })));
-});

package/tests/init-javascript/init-javascript.integtest.ts

@@ -1,58 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs-extra';
-import { integTest, withTemporaryDirectory, ShellHelper, withPackages } from '../../lib';
-
-['app', 'sample-app'].forEach(template => {
-  integTest(`init javascript ${template}`, withTemporaryDirectory(withPackages(async (context) => {
-    const shell = ShellHelper.fromContext(context);
-    await context.packages.makeCliAvailable();
-
-    await shell.shell(['cdk', 'init', '-l', 'javascript', template]);
-    await shell.shell(['npm', 'prune']);
-    await shell.shell(['npm', 'ls']); // this will fail if we have unmet peer dependencies
-    await shell.shell(['npm', 'run', 'test']);
-
-    await shell.shell(['cdk', 'synth']);
-  })));
-});
-
-integTest('Test importing CDK from ESM', withTemporaryDirectory(withPackages(async (context) => {
-  // Use 'cdk init -l=javascript' to get set up, but use a different file
-  const shell = ShellHelper.fromContext(context);
-  await context.packages.makeCliAvailable();
-
-  await shell.shell(['cdk', 'init', '-l', 'javascript', 'app']);
-
-  // Rewrite some files
-  await fs.writeFile(path.join(context.integTestDir, 'new-entrypoint.mjs'), `
-// Test multiple styles of imports
-import { Stack, aws_sns as sns } from 'aws-cdk-lib';
-import { SqsSubscription } from 'aws-cdk-lib/aws-sns-subscriptions';
-import * as sqs from 'aws-cdk-lib/aws-sqs';
-import * as cdk from 'aws-cdk-lib';
-
-class TestjsStack extends Stack {
-  constructor(scope, id, props) {
-    super(scope, id, props);
-
-    const queue = new sqs.Queue(this, 'TestjsQueue', {
-      visibilityTimeout: cdk.Duration.seconds(300)
-    });
-
-    const topic = new sns.Topic(this, 'TestjsTopic');
-
-    topic.addSubscription(new SqsSubscription(queue));
-  }
-}
-
-const app = new cdk.App();
-new TestjsStack(app, 'TestjsStack');
-`, { encoding: 'utf-8' });
-
-  // Rewrite 'cdk.json' to use new entrypoint
-  const cdkJson = await fs.readJson(path.join(context.integTestDir, 'cdk.json'));
-  cdkJson.app = 'node new-entrypoint.mjs';
-  await fs.writeJson(path.join(context.integTestDir, 'cdk.json'), cdkJson);
-
-  await shell.shell(['cdk', 'synth']);
-})));

package/tests/init-python/init-python.integtest.ts

@@ -1,20 +0,0 @@
-import * as path from 'path';
-import { integTest, withTemporaryDirectory, ShellHelper, withPackages } from '../../lib';
-
-['app', 'sample-app'].forEach(template => {
-  integTest(`init python ${template}`, withTemporaryDirectory(withPackages(async (context) => {
-    context.packages.assertJsiiPackagesAvailable();
-
-    const shell = ShellHelper.fromContext(context);
-    await context.packages.makeCliAvailable();
-
-    await shell.shell(['cdk', 'init', '-l', 'python', template]);
-    const venvPath = path.resolve(context.integTestDir, '.venv');
-    const venv = { PATH: `${venvPath}/bin:${process.env.PATH}`, VIRTUAL_ENV: venvPath };
-
-    await shell.shell([`${venvPath}/bin/pip`, 'install', '-r', 'requirements.txt'], { modEnv: venv });
-    await shell.shell([`${venvPath}/bin/pip`, 'install', '-r', 'requirements-dev.txt'], { modEnv: venv });
-    await shell.shell([`${venvPath}/bin/pytest`], { modEnv: venv });
-    await shell.shell(['cdk', 'synth'], { modEnv: venv });
-  })));
-});

package/tests/init-typescript-app/init-typescript-app.integtest.ts

@@ -1,67 +0,0 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import { integTest, withTemporaryDirectory, ShellHelper, withPackages, TemporaryDirectoryContext } from '../../lib';
-import { typescriptVersionsSync, typescriptVersionsYoungerThanDaysSync } from '../../lib/npm';
-
-['app', 'sample-app'].forEach(template => {
-  integTest(`typescript init ${template}`, withTemporaryDirectory(withPackages(async (context) => {
-    const shell = ShellHelper.fromContext(context);
-    await context.packages.makeCliAvailable();
-
-    await shell.shell(['cdk', 'init', '-l', 'typescript', template]);
-
-    await shell.shell(['npm', 'prune']);
-    await shell.shell(['npm', 'ls']); // this will fail if we have unmet peer dependencies
-    await shell.shell(['npm', 'run', 'build']);
-    await shell.shell(['npm', 'run', 'test']);
-
-    await shell.shell(['cdk', 'synth']);
-  })));
-});
-
-// Same as https://github.com/DefinitelyTyped/DefinitelyTyped?tab=readme-ov-file#support-window
-const TYPESCRIPT_VERSION_AGE_DAYS = 2 * 365;
-
-const TYPESCRIPT_VERSIONS = typescriptVersionsYoungerThanDaysSync(TYPESCRIPT_VERSION_AGE_DAYS, typescriptVersionsSync());
-
-/**
- * Test our generated code with various versions of TypeScript
- */
-TYPESCRIPT_VERSIONS.forEach(tsVersion => {
-  integTest(`typescript ${tsVersion} init app`, withTemporaryDirectory(withPackages(async (context) => {
-    const shell = ShellHelper.fromContext(context);
-    await context.packages.makeCliAvailable();
-
-    await shell.shell(['node', '--version']);
-    await shell.shell(['npm', '--version']);
-
-    await shell.shell(['cdk', 'init', '-l', 'typescript', 'app', '--generate-only']);
-
-    // Necessary because recent versions of ts-jest require TypeScript>=4.3 but we
-    // still want to test with older versions as well.
-    await removeDevDependencies(context);
-
-    await shell.shell(['npm', 'install', '--save-dev', `typescript@${tsVersion}`]);
-
-    // After we've removed devDependencies we need to re-install ts-node because it's necessary for `cdk synth`
-    await shell.shell(['npm', 'install', '--save-dev', 'ts-node@^10']);
-
-    await shell.shell(['npm', 'install']); // Older versions of npm require this to be a separate step from the one above
-    await shell.shell(['npx', 'tsc', '--version']);
-    await shell.shell(['npm', 'prune']);
-    await shell.shell(['npm', 'ls']); // this will fail if we have unmet peer dependencies
-
-    // We just removed the 'jest' dependency so remove the tests as well because they won't compile
-    await shell.shell(['rm', '-rf', 'test/']);
-
-    await shell.shell(['npm', 'run', 'build']);
-    await shell.shell(['cdk', 'synth']);
-  })));
-});
-
-async function removeDevDependencies(context: TemporaryDirectoryContext) {
-  const filename = path.join(context.integTestDir, 'package.json');
-  const pj = JSON.parse(await fs.readFile(filename, { encoding: 'utf-8' }));
-  delete pj.devDependencies;
-  await fs.writeFile(filename, JSON.stringify(pj, undefined, 2), { encoding: 'utf-8' });
-}

package/tests/init-typescript-lib/init-typescript-lib.integtest.ts

@@ -1,13 +0,0 @@
-import { integTest, withTemporaryDirectory, ShellHelper, withPackages } from '../../lib';
-
-integTest('typescript init lib', withTemporaryDirectory(withPackages(async (context) => {
-  const shell = ShellHelper.fromContext(context);
-  await context.packages.makeCliAvailable();
-
-  await shell.shell(['cdk', 'init', '-l', 'typescript', 'lib']);
-
-  await shell.shell(['npm', 'prune']);
-  await shell.shell(['npm', 'ls']); // this will fail if we have unmet peer dependencies
-  await shell.shell(['npm', 'run', 'build']);
-  await shell.shell(['npm', 'run', 'test']);
-})));