aws · mergify · Nov 25, 2024 · Nov 25, 2024 · Nov 25, 2024 · Nov 25, 2024
@@ -20,6 +20,5 @@ module.exports = {
 
     // We have many tests here that commonly time out
     testTimeout: 30_000,
-    // These tests are too chatty. Shush.
-    silent: true,
+    setupFilesAfterEnv: ["<rootDir>/test/jest-setup-after-env.ts"],
 };
@@ -324,13 +324,9 @@ async function initializeProject(
   if (migrate) {
     await template.addMigrateContext(workDir);
   }
-  if (await fs.pathExists('README.md')) {
-    const readme = await fs.readFile('README.md', { encoding: 'utf-8' });
-    // Save the logs!
-    // Without this statement, the readme of the CLI is printed in every init test
-    if (!readme.startsWith('# AWS CDK Toolkit')) {
-      print(chalk.green(readme));
-    }
+  if (await fs.pathExists(`${workDir}/README.md`)) {
+    const readme = await fs.readFile(`${workDir}/README.md`, { encoding: 'utf-8' });
+    print(chalk.green(readme));
   }
 
   if (!generateOnly) {

@@ -1,4 +1,6 @@
 import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
 import { Writable } from 'stream';
 import { StringDecoder } from 'string_decoder';
 import * as cxschema from '@aws-cdk/cloud-assembly-schema';
@@ -12,6 +14,22 @@ import { CdkToolkit } from '../lib/cdk-toolkit';
 let cloudExecutable: MockCloudExecutable;
 let cloudFormation: jest.Mocked<Deployments>;
 let toolkit: CdkToolkit;
+let oldDir: string;
+let tmpDir: string;
+
+beforeAll(() => {
+  // The toolkit writes and checks for temporary files in the current directory,
+  // so run these tests in a tempdir so they don't interfere with each other
+  // and other tests.
+  oldDir = process.cwd();
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'aws-cdk-test'));
+  process.chdir(tmpDir);
+});
+
+afterAll(() => {
+  process.chdir(oldDir);
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
 
 describe('fixed template', () => {
   const templatePath = 'oldTemplate.json';

@@ -2,7 +2,7 @@ import * as os from 'os';
 import * as path from 'path';
 import * as cxapi from '@aws-cdk/cx-api';
 import * as fs from 'fs-extra';
-import { availableInitTemplates, cliInit } from '../lib/init';
+import { availableInitLanguages, availableInitTemplates, cliInit, printAvailableTemplates } from '../lib/init';
 
 describe('constructs version', () => {
   cliTest('create a TypeScript library project', async (workDir) => {
@@ -17,6 +17,21 @@ describe('constructs version', () => {
     expect(await fs.pathExists(path.join(workDir, 'lib'))).toBeTruthy();
   });
 
+  cliTest('asking for a nonexistent template fails', async (workDir) => {
+    await expect(cliInit({
+      type: 'banana',
+      language: 'typescript',
+      workDir,
+    })).rejects.toThrow(/Unknown init template/);
+  });
+
+  cliTest('asking for a template but no language prints and throws', async (workDir) => {
+    await expect(cliInit({
+      type: 'app',
+      workDir,
+    })).rejects.toThrow(/No language/);
+  });
+
   cliTest('create a TypeScript app project', async (workDir) => {
     await cliInit({
       type: 'app',
@@ -237,6 +252,16 @@ test('when no version number is present (e.g., local development), the v2 templa
   expect((await availableInitTemplates()).length).toBeGreaterThan(0);
 });
 
+test('check available init languages', async () => {
+  const langs = await availableInitLanguages();
+  expect(langs.length).toBeGreaterThan(0);
+  expect(langs).toContain('typescript');
+});
+
+test('exercise printing available templates', async () => {
+  await printAvailableTemplates();
+});
+
 function cliTest(name: string, handler: (dir: string) => void | Promise<any>): void {
   test(name, () => withTempDir(handler));
 }

@@ -0,0 +1,85 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { isPromise } from 'util/types';
+
+/**
+ * Global test setup for Jest tests
+ *
+ * It's easy to accidentally write tests that interfere with each other by
+ * writing files to disk in the "current directory". To prevent this, the global
+ * test setup creates a directory in the temporary directory and chmods it to
+ * being non-writable. That way, whenever a test tries to write to the current
+ * directory, it will produce an error and we'll be able to find and fix the
+ * test.
+ *
+ * If you see `EACCES: permission denied`, you have a test that creates files
+ * in the current directory, and you should be sure to do it in a temporary
+ * directory that you clean up afterwards.
+ *
+ * ## Alternate approach
+ *
+ * I tried an approach where I would automatically try to create and clean up
+ * temp directories for every test, but it was introducing too many conflicts
+ * with existing test behavior (around specific ordering of temp directory
+ * creation and cleanup tasks that are already present) in many places that I
+ * didn't want to go and chase down.
+ *
+ */
+
+let tmpDir: string;
+let oldDir: string;
+
+beforeAll(() => {
+  tmpDir = path.join(os.tmpdir(), 'cdk-nonwritable-on-purpose');
+  fs.mkdirSync(tmpDir, { recursive: true });
+  fs.chmodSync(tmpDir, 0o500);
+  oldDir = process.cwd();
+  process.chdir(tmpDir);
+  tmpDir = process.cwd(); // This will have resolved symlinks
+});
+
+const reverseAfterAll: Array<jest.ProvidesHookCallback> = [];
+
+/**
+ * We need a cleanup here
+ *
+ * 99% of the time, Jest runs the tests in a subprocess and this isn't
+ * necessary because we would have `chdir`ed in the subprocess.
+ *
+ * But sometimes we ask Jest with `-i` to run the tests in the main process,
+ * or if you only ask for a single test suite Jest runs the tests in the main
+ * process, and then we `chdir`ed the main process away.
+ *
+ * Jest will then try to write the `coverage` directory to the readonly directory,
+ * and fail. Chdir back to the original dir.
+ *
+ * If the test file has an `afterAll()` hook it installed as well, we need to run
+ * it before our cleanup, otherwise the wrong thing will happen (by default,
+ * all `afterAll()`s run in call order, but they should be run in reverse).
+ */
+afterAll(async () => {
+  for (const aft of reverseAfterAll.reverse()) {
+    await new Promise<void>((resolve, reject) => {
+      const response = aft(resolve as any);
+      if (isPromise(response)) {
+        response.then(() => { return resolve(); }, reject);
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  // eslint-disable-next-line no-console
+  process.stderr.write(`${process.cwd()}, ${tmpDir}\n`);
+  if (process.cwd() === tmpDir) {
+    // eslint-disable-next-line no-console
+    process.stderr.write('chmod\n');
+    process.chdir(oldDir);
+  }
+});
+
+// Patch afterAll to make later-provided afterAll's run before us (in reverse order even).
+afterAll = (after: jest.ProvidesHookCallback) => {
+  reverseAfterAll.push(after);
+};
@@ -455,23 +455,20 @@ describe(CachedDataSource, () => {
   });
 
   test('retrieves data from the delegate when the file cannot be read', async () => {
-    const debugSpy = jest.spyOn(logging, 'debug');
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cdk-test'));
+    try {
+      const debugSpy = jest.spyOn(logging, 'debug');
 
-    if (fs.existsSync('does-not-exist.json')) {
-      fs.unlinkSync('does-not-exist.json');
-    }
-
-    const dataSource = dataSourceWithDelegateReturning(freshData, 'does-not-exist.json');
+      const dataSource = dataSourceWithDelegateReturning(freshData, `${tmpDir}/does-not-exist.json`);
 
-    const notices = await dataSource.fetch();
-
-    expect(notices).toEqual(freshData);
-    expect(debugSpy).not.toHaveBeenCalled();
+      const notices = await dataSource.fetch();
 
-    debugSpy.mockRestore();
+      expect(notices).toEqual(freshData);
+      expect(debugSpy).not.toHaveBeenCalled();
 
-    if (fs.existsSync('does-not-exist.json')) {
-      fs.unlinkSync('does-not-exist.json');
+      debugSpy.mockRestore();
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });