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

package/tests/cli-integ-tests/cdk-test-cdk-rollback---force.integtest.ts

@@ -1,48 +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(
-  'test cdk rollback --force',
-  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 = '2b'; // Fail update and also fail rollback
-
-      // Should fail
-      const deployOutput = await fixture.cdkDeploy('test-rollback', {
-        options: ['--no-rollback'],
-        modEnv: { PHASE: phase },
-        verbose: false,
-        allowErrExit: true,
-      });
-
-      expect(deployOutput).toContain('UPDATE_FAILED');
-
-      // Should still fail
-      const rollbackOutput = await fixture.cdk(['rollback'], {
-        modEnv: { PHASE: phase },
-        verbose: false,
-        allowErrExit: true,
-      });
-
-      expect(rollbackOutput).toContain('Failing rollback');
-
-      // Rollback and force cleanup
-      await fixture.cdk(['rollback', '--force'], {
-        modEnv: { PHASE: phase },
-        verbose: false,
-      });
-    } finally {
-      await fixture.cdkDestroy('test-rollback');
-    }
-  }),
-);
-

package/tests/cli-integ-tests/cdk-test-cdk-rollback.integtest.ts

@@ -1,38 +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(
-  'test cdk rollback',
-  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');
-
-      // Rollback
-      await fixture.cdk(['rollback'], {
-        modEnv: { PHASE: phase },
-        verbose: false,
-      });
-    } finally {
-      await fixture.cdkDestroy('test-rollback');
-    }
-  }),
-);
-

package/tests/cli-integ-tests/cdk-test-migrate-deployment-for-app-with-localfile-source-in-migrate.json.integtest.ts

@@ -1,56 +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(
-  'test migrate deployment for app with localfile source in migrate.json',
-  withDefaultFixture(async (fixture) => {
-    const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json');
-    await fs.mkdir(path.dirname(outputsFile), { recursive: true });
-
-    // Initial deploy
-    await fixture.cdkDeploy('migrate-stack', {
-      modEnv: { ORPHAN_TOPIC: '1' },
-      options: ['--outputs-file', outputsFile],
-    });
-
-    const outputs = JSON.parse((await fs.readFile(outputsFile, { encoding: 'utf-8' })).toString());
-    const stackName = fixture.fullStackName('migrate-stack');
-    const queueName = outputs[stackName].QueueName;
-    const queueUrl = outputs[stackName].QueueUrl;
-    const queueLogicalId = outputs[stackName].QueueLogicalId;
-    fixture.log(`Created queue ${queueUrl} in stack ${fixture.fullStackName}`);
-
-    // Write the migrate file based on the ID from step one, then deploy the app with migrate
-    const migrateFile = path.join(fixture.integTestDir, 'migrate.json');
-    await fs.writeFile(
-      migrateFile,
-      JSON.stringify({
-        Source: 'localfile',
-        Resources: [
-          {
-            ResourceType: 'AWS::SQS::Queue',
-            LogicalResourceId: queueLogicalId,
-            ResourceIdentifier: { QueueUrl: queueUrl },
-          },
-        ],
-      }),
-      { encoding: 'utf-8' },
-    );
-
-    await fixture.cdkDestroy('migrate-stack');
-    fixture.log(`Deleted stack ${fixture.fullStackName}, orphaning ${queueName}`);
-
-    // Create new stack from existing queue
-    try {
-      fixture.log(`Deploying new stack ${fixture.fullStackName}, migrating ${queueName} into stack`);
-      await fixture.cdkDeploy('migrate-stack');
-    } finally {
-      // Cleanup
-      await fixture.cdkDestroy('migrate-stack');
-    }
-  }),
-);
-

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']);
-  })));
-});