Add new tests

Author: rix0rrr

packages/@aws-cdk/tmp-toolkit-helpers/src/api/rwlock.ts

@@ -32,7 +32,7 @@ export class RWLock {
   public async acquireWrite(): Promise<IWriteLock> {
     await this.assertNoOtherWriters();
 
-    const readers = await this.currentReaders();
+    const readers = await this._currentReaders();
     if (readers.length > 0) {
       throw new ToolkitError(`Other CLIs (PID=${readers}) are currently reading from ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
     }
@@ -99,16 +99,20 @@ export class RWLock {
   }
 
   private async assertNoOtherWriters() {
-    const writer = await this.currentWriter();
+    const writer = await this._currentWriter();
     if (writer) {
       throw new ToolkitError(`Another CLI (PID=${writer}) is currently synthing to ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
     }
   }
 
   /**
    * Check the current writer (if any)
+   *
+   * Publicly accessible for testing purposes. Do not use.
+   *
+   * @internal
    */
-  private async currentWriter(): Promise<number | undefined> {
+  public async _currentWriter(): Promise<number | undefined> {
     const contents = await readFileIfExists(this.writerFile);
     if (!contents) {
       return undefined;
@@ -126,8 +130,12 @@ export class RWLock {
 
   /**
    * Check the current readers (if any)
+   *
+   * Publicly accessible for testing purposes. Do not use.
+   *
+   * @internal
    */
-  private async currentReaders(): Promise<number[]> {
+  public async _currentReaders(): Promise<number[]> {
     const re = /^read\.([^.]+)\.[^.]+\.lock$/;
     const ret = new Array<number>();
 

packages/@aws-cdk/toolkit-lib/test/_helpers/index.ts

@@ -1,8 +1,9 @@
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import type { AssemblyDirectoryProps, Toolkit } from '../../lib';
+import type { AssemblyDirectoryProps, ICloudAssemblySource } from '../../lib';
 import { ToolkitError } from '../../lib';
+import type { CloudAssemblySourceBuilder } from '../../lib/api/cloud-assembly/private';
 
 export * from './test-cloud-assembly-source';
 export * from './test-io-host';
@@ -11,7 +12,7 @@ function fixturePath(...parts: string[]): string {
   return path.normalize(path.join(__dirname, '..', '_fixtures', ...parts));
 }
 
-export async function appFixture(toolkit: Toolkit, name: string, context?: { [key: string]: any }) {
+export async function appFixture(toolkit: CloudAssemblySourceBuilder, name: string, context?: { [key: string]: any }) {
   const appPath = fixturePath(name, 'app.js');
   if (!fs.existsSync(appPath)) {
     throw new ToolkitError(`App Fixture ${name} does not exist in ${appPath}`);
@@ -24,7 +25,7 @@ export async function appFixture(toolkit: Toolkit, name: string, context?: { [ke
   });
 }
 
-export function builderFixture(toolkit: Toolkit, name: string, context?: { [key: string]: any }) {
+export function builderFixture(toolkit: CloudAssemblySourceBuilder, name: string, context?: { [key: string]: any }) {
   // eslint-disable-next-line @typescript-eslint/no-require-imports
   const builder = require(path.join(__dirname, '..', '_fixtures', name)).default;
   return toolkit.fromAssemblyBuilder(builder, {
@@ -33,7 +34,7 @@ export function builderFixture(toolkit: Toolkit, name: string, context?: { [key:
   });
 }
 
-export function cdkOutFixture(toolkit: Toolkit, name: string, props: AssemblyDirectoryProps = {}) {
+export function cdkOutFixture(toolkit: CloudAssemblySourceBuilder, name: string, props: AssemblyDirectoryProps = {}) {
   const outdir = path.join(__dirname, '..', '_fixtures', name, 'cdk.out');
   if (!fs.existsSync(outdir)) {
     throw new ToolkitError(`Assembly Dir Fixture ${name} does not exist in ${outdir}`);
@@ -44,3 +45,44 @@ export function cdkOutFixture(toolkit: Toolkit, name: string, props: AssemblyDir
 function tmpOutdir(): string {
   return fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'cdk.out'));
 }
+
+/**
+ * A temporary directory that cleans when it goes out of scope
+ *
+ * Use with `using`. Could have been async but it's depending
+ * on an already-sync API, so why not sync?
+ */
+export function autoCleanOutDir() {
+  const dir = tmpOutdir();
+  return {
+    dir,
+    [Symbol.dispose]: async () => {
+      fs.rmSync(dir, { force: true, recursive: true });
+    },
+  };
+}
+
+export async function disposableCloudAssemblySource(
+  toolkit: CloudAssemblySourceBuilder,
+): Promise<[ICloudAssemblySource, ReturnType<typeof jest.fn>]> {
+  // We just need any kind of assembly
+  const fixtureSource = await cdkOutFixture(toolkit, 'stack-with-bucket');
+  const cloudAssembly = await fixtureSource.produce();
+
+  const mockDispose = jest.fn();
+  const assemblySource: ICloudAssemblySource = {
+    produce() {
+      return Promise.resolve({
+        cloudAssembly: cloudAssembly.cloudAssembly,
+
+        _unlock: jest.fn(),
+
+        // Doesn't matter which one we use
+        dispose: mockDispose,
+        [Symbol.asyncDispose]: mockDispose,
+      });
+    },
+  };
+
+  return [assemblySource, mockDispose];
+}

packages/@aws-cdk/toolkit-lib/test/actions/bootstrap.test.ts

@@ -14,7 +14,7 @@ import type { BootstrapOptions } from '../../lib/actions/bootstrap';
 import { BootstrapEnvironments, BootstrapSource, BootstrapStackParameters } from '../../lib/actions/bootstrap';
 import { SdkProvider } from '../../lib/api/shared-private';
 import { Toolkit } from '../../lib/toolkit';
-import { TestIoHost, builderFixture } from '../_helpers';
+import { TestIoHost, builderFixture, disposableCloudAssemblySource } from '../_helpers';
 import {
   MockSdkProvider,
   MockSdk,
@@ -478,6 +478,24 @@ describe('bootstrap', () => {
     }));
   });
 
+  test('action disposes of assembly produced by source', async () => {
+    // GIVEN
+    const mockStack1 = createMockStack([
+      { OutputKey: 'BucketName', OutputValue: 'BUCKET_NAME_1' },
+      { OutputKey: 'BucketDomainName', OutputValue: 'BUCKET_ENDPOINT_1' },
+      { OutputKey: 'BootstrapVersion', OutputValue: '1' },
+    ]);
+    setupMockCloudFormationClient(mockStack1);
+
+    const [assemblySource, mockDispose] = await disposableCloudAssemblySource(toolkit);
+
+    // WHEN
+    await toolkit.bootstrap(BootstrapEnvironments.fromCloudAssemblySource(assemblySource), { });
+
+    // THEN
+    expect(mockDispose).toHaveBeenCalled();
+  });
+
   describe('error handling', () => {
     test('returns correct BootstrapResult for successful bootstraps', async () => {
     // GIVEN

packages/@aws-cdk/toolkit-lib/test/actions/deploy.test.ts

@@ -3,7 +3,7 @@ import type { DeployStackOptions, DeployStackResult } from '../../lib/api/shared
 import * as apis from '../../lib/api/shared-private';
 import { RequireApproval } from '../../lib/api/shared-private';
 import { Toolkit } from '../../lib/toolkit';
-import { builderFixture, cdkOutFixture, TestIoHost } from '../_helpers';
+import { builderFixture, cdkOutFixture, disposableCloudAssemblySource, TestIoHost } from '../_helpers';
 import { MockSdk } from '../_helpers/mock-sdk';
 
 let ioHost: TestIoHost;
@@ -362,6 +362,17 @@ describe('deploy', () => {
       ],
     });
   });
+
+  test('action disposes of assembly produced by source', async () => {
+    // GIVEN
+    const [assemblySource, mockDispose] = await disposableCloudAssemblySource(toolkit);
+
+    // WHEN
+    await toolkit.deploy(assemblySource);
+
+    // THEN
+    expect(mockDispose).toHaveBeenCalled();
+  });
 });
 
 function successfulDeployment() {

packages/@aws-cdk/toolkit-lib/test/actions/destroy.test.ts

@@ -1,11 +1,12 @@
 import * as chalk from 'chalk';
 import { StackSelectionStrategy } from '../../lib/api/shared-public';
+import type { RollbackResult } from '../../lib/toolkit';
 import { Toolkit } from '../../lib/toolkit';
-import { builderFixture, TestIoHost } from '../_helpers';
+import { builderFixture, disposableCloudAssemblySource, TestIoHost } from '../_helpers';
 
 const ioHost = new TestIoHost();
 const toolkit = new Toolkit({ ioHost });
-jest.spyOn(toolkit, 'rollback').mockResolvedValue();
+jest.spyOn(toolkit, 'rollback').mockResolvedValue({ stacks: [] } satisfies RollbackResult);
 
 let mockDestroyStack = jest.fn();
 
@@ -86,6 +87,19 @@ describe('destroy', () => {
       message: expect.stringContaining('destroy failed'),
     }));
   });
+
+  test('action disposes of assembly produced by source', async () => {
+    // GIVEN
+    const [assemblySource, mockDispose] = await disposableCloudAssemblySource(toolkit);
+
+    // WHEN
+    await toolkit.destroy(assemblySource, {
+      stacks: { strategy: StackSelectionStrategy.ALL_STACKS },
+    });
+
+    // THEN
+    expect(mockDispose).toHaveBeenCalled();
+  });
 });
 
 function successfulDestroy() {

packages/@aws-cdk/toolkit-lib/test/actions/diff.test.ts

@@ -6,7 +6,7 @@ import * as apis from '../../lib/api/shared-private';
 import { RequireApproval } from '../../lib/api/shared-private';
 import { StackSelectionStrategy } from '../../lib/api/shared-public';
 import { Toolkit } from '../../lib/toolkit';
-import { builderFixture, TestIoHost } from '../_helpers';
+import { builderFixture, disposableCloudAssemblySource, TestIoHost } from '../_helpers';
 import { MockSdk } from '../_helpers/mock-sdk';
 
 let ioHost: TestIoHost;
@@ -262,4 +262,17 @@ describe('diff', () => {
     //   }));
     // });
   });
+
+  test('action disposes of assembly produced by source', async () => {
+    // GIVEN
+    const [assemblySource, mockDispose] = await disposableCloudAssemblySource(toolkit);
+
+    // WHEN
+    await toolkit.diff(assemblySource, {
+      stacks: { strategy: StackSelectionStrategy.ALL_STACKS },
+    });
+
+    // THEN
+    expect(mockDispose).toHaveBeenCalled();
+  });
 });

packages/@aws-cdk/toolkit-lib/test/actions/list.test.ts

@@ -1,7 +1,7 @@
 import { ArtifactMetadataEntryType } from '@aws-cdk/cloud-assembly-schema';
 import { StackSelectionStrategy } from '../../lib/api/shared-private';
 import { Toolkit } from '../../lib/toolkit';
-import { TestIoHost } from '../_helpers';
+import { disposableCloudAssemblySource, TestIoHost } from '../_helpers';
 import type { TestStackArtifact } from '../_helpers/test-cloud-assembly-source';
 import { TestCloudAssemblySource } from '../_helpers/test-cloud-assembly-source';
 
@@ -458,6 +458,19 @@ describe('list', () => {
     await expect(() => toolkit.list(cx)).rejects.toThrow('Could not determine ordering');
     expect(ioHost.notifySpy).not.toHaveBeenCalled();
   });
+
+  test('action disposes of assembly produced by source', async () => {
+    // GIVEN
+    const [assemblySource, mockDispose] = await disposableCloudAssemblySource(toolkit);
+
+    // WHEN
+    await toolkit.list(assemblySource, {
+      stacks: { strategy: StackSelectionStrategy.ALL_STACKS },
+    });
+
+    // THEN
+    expect(mockDispose).toHaveBeenCalled();
+  });
 });
 
 const MOCK_STACK_A: TestStackArtifact = {

packages/@aws-cdk/toolkit-lib/test/actions/rollback.test.ts

@@ -1,6 +1,6 @@
 import { StackSelectionStrategy } from '../../lib/api/shared-private';
 import { Toolkit } from '../../lib/toolkit';
-import { builderFixture, TestIoHost } from '../_helpers';
+import { builderFixture, disposableCloudAssemblySource, TestIoHost } from '../_helpers';
 
 const ioHost = new TestIoHost();
 const toolkit = new Toolkit({ ioHost });
@@ -82,6 +82,19 @@ describe('rollback', () => {
       stacks: { strategy: StackSelectionStrategy.ALL_STACKS },
     })).rejects.toThrow(/Rollback failed/);
   });
+
+  test('action disposes of assembly produced by source', async () => {
+    // GIVEN
+    const [assemblySource, mockDispose] = await disposableCloudAssemblySource(toolkit);
+
+    // WHEN
+    await toolkit.rollback(assemblySource, {
+      stacks: { strategy: StackSelectionStrategy.ALL_STACKS },
+    });
+
+    // THEN
+    expect(mockDispose).toHaveBeenCalled();
+  });
 });
 
 function successfulRollback() {

packages/@aws-cdk/toolkit-lib/test/actions/synth.test.ts

@@ -1,5 +1,5 @@
 import { Toolkit } from '../../lib/toolkit';
-import { appFixture, builderFixture, TestIoHost } from '../_helpers';
+import { appFixture, builderFixture, disposableCloudAssemblySource, TestIoHost } from '../_helpers';
 
 // these tests often run a bit longer than the default
 jest.setTimeout(10_000);
@@ -77,4 +77,18 @@ describe('synth', () => {
       }),
     }));
   });
+
+  test('output of synth can be used in other toolkit actions, but source is only disposed at the end', async () => {
+    // GIVEN
+    const [assemblySource, mockDispose] = await disposableCloudAssemblySource(toolkit);
+    const synthResult = await toolkit.synth(assemblySource);
+
+    // WHEN
+    await toolkit.list(synthResult);
+    expect(mockDispose).not.toHaveBeenCalled();
+
+    // WHEN
+    await synthResult.dispose();
+    expect(mockDispose).toHaveBeenCalled();
+  });
 });

packages/@aws-cdk/toolkit-lib/test/actions/watch.test.ts

@@ -47,7 +47,7 @@ jest.mock('chokidar', () => ({
 import * as path from 'node:path';
 import { HotswapMode } from '../../lib/actions/deploy';
 import { Toolkit } from '../../lib/toolkit';
-import { builderFixture, TestIoHost } from '../_helpers';
+import { builderFixture, disposableCloudAssemblySource, TestIoHost } from '../_helpers';
 
 const ioHost = new TestIoHost();
 const toolkit = new Toolkit({ ioHost });
@@ -238,6 +238,21 @@ describe('watch', () => {
       extraUserAgent: 'cdk-watch/hotswap-on',
     }));
   });
+
+  test('action disposes of assembly produced by source', async () => {
+    // GIVEN
+    const [assemblySource, mockDispose] = await disposableCloudAssemblySource(toolkit);
+
+    // WHEN
+    const watcher = await toolkit.watch(assemblySource, {
+      include: [],
+      hotswap: undefined, // force the default
+    });
+    await watcher.dispose();
+
+    // THEN
+    expect(mockDispose).toHaveBeenCalled();
+  });
 });
 
 // @todo unit test watch with file events