@aws-cdk-testing/cli-integ 2.173.3 → 3.0.0

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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,66 @@
+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());
+
+// eslint-disable-next-line no-console
+console.log(TYPESCRIPT_VERSIONS);
+
+/**
+ * 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}`]);
+    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

@@ -0,0 +1,13 @@
+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']);
+})));

package/tests/tool-integrations/amplify.integtest.ts

@@ -0,0 +1,43 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { withToolContext } from './with-tool-context';
+import { integTest, ShellHelper, TemporaryDirectoryContext } from '../../lib';
+
+const TIMEOUT = 1800_000;
+
+integTest('amplify integration', withToolContext(async (context) => {
+  const shell = ShellHelper.fromContext(context);
+
+  await shell.shell(['npm', 'create', '-y', 'amplify@latest']);
+  await shell.shell(['npx', 'ampx', 'configure', 'telemetry', 'disable']);
+
+  // This will create 'package.json' implicating a certain version of the CDK
+  await updateCdkDependency(context, context.packages.requestedCliVersion(), context.packages.requestedFrameworkVersion());
+  await shell.shell(['npm', 'install']);
+
+  await shell.shell(['npx', 'ampx', 'sandbox', '--once'], {
+    modEnv: {
+      AWS_REGION: context.aws.region,
+    },
+  });
+  try {
+
+    // Future code goes here, putting the try/finally here already so it doesn't
+    // get forgotten.
+
+  } finally {
+    await shell.shell(['npx', 'ampx', 'sandbox', 'delete', '--yes'], {
+      modEnv: {
+        AWS_REGION: context.aws.region,
+      },
+    });
+  }
+}), TIMEOUT);
+
+async function updateCdkDependency(context: TemporaryDirectoryContext, cliVersion: string, libVersion: string) {
+  const filename = path.join(context.integTestDir, 'package.json');
+  const pj = JSON.parse(await fs.readFile(filename, { encoding: 'utf-8' }));
+  pj.devDependencies['aws-cdk'] = cliVersion;
+  pj.devDependencies['aws-cdk-lib'] = libVersion;
+  await fs.writeFile(filename, JSON.stringify(pj, undefined, 2), { encoding: 'utf-8' });
+}

package/tests/tool-integrations/with-tool-context.ts

@@ -0,0 +1,14 @@
+import { TestContext } from '../../lib/integ-test';
+import { AwsContext, withAws } from '../../lib/with-aws';
+import { DisableBootstrapContext } from '../../lib/with-cdk-app';
+import { PackageContext, withPackages } from '../../lib/with-packages';
+import { TemporaryDirectoryContext, withTemporaryDirectory } from '../../lib/with-temporary-directory';
+
+/**
+ * The default prerequisites for tests running tool integrations
+ */
+export function withToolContext<A extends TestContext>(
+  block: (context: A & TemporaryDirectoryContext & PackageContext & AwsContext & DisableBootstrapContext
+  ) => Promise<void>) {
+  return withAws(withTemporaryDirectory(withPackages(block)));
+}

package/tests/uberpackage/uberpackage.integtest.ts

@@ -0,0 +1,11 @@
+import { integTest, withMonolithicCfnIncludeCdkApp } from '../../lib';
+
+jest.setTimeout(600_000);
+
+describe('uberpackage', () => {
+  integTest('works with cloudformation-include', withMonolithicCfnIncludeCdkApp(async (fixture) => {
+    fixture.log('Starting test of cfn-include with monolithic CDK');
+
+    await fixture.cdkSynth();
+  }));
+});

package/resources/cdk-apps/cfn-include-app/.gitignore

@@ -1 +0,0 @@
-!cfn-include-app.js