e2e working

package.json

@@ -12,7 +12,7 @@
     "clean:npm-proxy": "npm run stop:npm-proxy && rimraf verdaccio-cache verdaccio-logs.txt",
     "diff:check": "tsx scripts/check_pr_size.ts",
     "docs": "typedoc",
-    "e2e": "tsx --test --test-reporter spec --test-name-pattern /^\\[E2E\\]/",
+    "e2e": "tsx --test --test-reporter spec --test-name-pattern \"/^\\[E2E\\]/\"",
     "install:local": "npm install && npm run build && npm run install:local --workspaces --if-present",
     "lint": "eslint --max-warnings 0 . && prettier --check .",
     "lint:fix": "eslint --cache --fix . && prettier --write .",

packages/integration-tests/src/e2e/sandbox.test.ts

@@ -2,8 +2,9 @@ import { after, afterEach, before, beforeEach, describe, it } from 'node:test';
 import path from 'path';
 import { existsSync } from 'fs';
 import fs from 'fs/promises';
-import assert from 'node:assert';
+import { fileURLToPath } from 'url';
 import { ProcessController } from '../process_controller.js';
+import assert from 'node:assert';
 
 describe('[E2E] sandbox', () => {
   const e2eSandboxDir = new URL('./e2e-sandboxes', import.meta.url);
@@ -17,55 +18,64 @@ describe('[E2E] sandbox', () => {
     await fs.rm(e2eSandboxDir, { recursive: true });
   });
 
-  let testDir: string;
+  let testProjectRoot: string;
+  let testAmplifyDir: string;
   beforeEach(async () => {
-    testDir = await fs.mkdtemp(
-      path.join(e2eSandboxDir.toString(), 'test-create-amplify')
+    testProjectRoot = await fs.mkdtemp(
+      path.join(fileURLToPath(e2eSandboxDir), 'test-sandbox')
     );
-    // creating a package.json beforehand skips the npm init in create-amplify
     await fs.writeFile(
-      path.join(testDir, 'package.json'),
-      JSON.stringify({ name: 'test-project-name' }, null, 2)
+      path.join(testProjectRoot, 'package.json'),
+      JSON.stringify({ name: 'test-sandbox' }, null, 2)
     );
+
+    testAmplifyDir = path.join(testProjectRoot, 'amplify');
+    await fs.mkdir(testAmplifyDir);
+  });
+
+  afterEach(async () => {
+    await fs.rm(testAmplifyDir, { recursive: true });
   });
 
   const testProjects = [
     {
-      initialStatePath: new URL(
-        '../test-projects/basic-auth-data-storage-function',
+      initialAmplifyDirPath: new URL(
+        '../../test-projects/basic-auth-data-storage-function/amplify',
         import.meta.url
       ),
       name: 'basic-auth-data-storage-function',
     },
   ];
 
-  afterEach(async () => {
-    await fs.rm(testDir, { recursive: true });
-  });
+  testProjects.forEach((testProject) => {
+    it(`[E2E] ${testProject.name}`, async () => {
+      await fs.cp(testProject.initialAmplifyDirPath, testAmplifyDir, {
+        recursive: true,
+      });
 
-  describe('sandbox', () => {
-    it('deploys fully loaded project', async () => {
-      const sandboxProcess = ProcessController.fromCommand(
-        'npx',
-        ['amplify', 'sandbox'],
-        { cwd: testDir }
-      );
-      await sandboxProcess.waitForLineIncludes(
-        '[Sandbox] Watching for file changes'
-      );
-      sandboxProcess.kill();
-      const clientConfig = await import(
-        path.join(testDir, 'amplifyconfiguration.js')
+      const proc = new ProcessController('amplify', ['sandbox'], {
+        cwd: testProjectRoot,
+      })
+        .waitForLineIncludes('[Sandbox] Watching for file changes')
+        .sendCtrlC()
+        .waitForLineIncludes(
+          'Would you like to delete all the resources in your sandbox environment'
+        )
+        .sendNo();
+
+      await proc.run();
+      const { default: clientConfig } = await import(
+        path.join(testProjectRoot, 'amplifyconfiguration.js')
       );
       assert.deepStrictEqual(Object.keys(clientConfig).sort(), [
-        'aws_user_pools_id',
-        'aws_user_pools_web_client_id',
-        'aws_cognito_region',
+        'aws_appsync_authenticationType',
         'aws_appsync_graphqlEndpoint',
         'aws_appsync_region',
-        'aws_appsync_authenticationType',
-        'aws_user_files_s3_bucket_region',
+        'aws_cognito_region',
         'aws_user_files_s3_bucket',
+        'aws_user_files_s3_bucket_region',
+        'aws_user_pools_id',
+        'aws_user_pools_web_client_id',
       ]);
     });
   });

packages/integration-tests/src/process_controller.ts

@@ -1,46 +1,50 @@
-/**
- *
- */
-import { ExecaChildProcess, Options, execa } from 'execa';
+import { Options, execa } from 'execa';
 import * as os from 'os';
-import * as readline from 'readline';
-import { Interface } from 'readline';
+import readline from 'readline';
+
+type ExpectedLineAction = {
+  predicate: (line: string) => boolean;
+  thenSend: string[];
+};
+
+const CONTROL_C = '\x03';
 
 /**
  * Provides an abstractions for sending and receiving data on stdin/out of a child process
+ *
+ * The general strategy is a builder pattern which appends actions to a queue
+ * Then when .run() is called, the child process is spawned and the actions are executed one by one
+ *
+ * Each action is essentially a condition to wait for stdout to satisfy and some data to send on stdin once the wait condition is met
+ *
+ * For example `.waitForLineIncludes('Do you like M&Ms').sendLine('yes')`
+ * will wait until a line that includes "Do you like M&Ms" is printed on stdout of the child process,
+ * then send "yes" on stdin of the process
  */
 export class ProcessController {
-  private readonly processInterface: Interface;
+  private readonly expectedLineQueue: ExpectedLineAction[] = [];
   /**
    * Private ctor that initializes a readline interface around the execa process
    */
-  private constructor(private readonly execaProcess: ExecaChildProcess) {
-    if (!execaProcess.stdout || !execaProcess.stdin) {
-      throw new Error(`Process does not have stdout and stdin`);
-    }
-    // We are creating an interface with the child process stdout as the input and stdin as the output
-    // This is because the _output_ of the child process in the input that we want to process here
-    // and the _input_ of the child process is where we want to send commands (the output from this controller)
-    this.processInterface = readline.createInterface(
-      execaProcess.stdout,
-      execaProcess.stdin
-    );
-    this.processInterface.pause();
-  }
+  constructor(
+    private readonly command: string,
+    private readonly args: string[] = [],
+    private readonly options?: Pick<Options, 'cwd'>
+  ) {}
 
-  /**
-   * Factory method to initialize with a command and args
-   */
-  static fromCommand = (
-    command: string,
-    args: string[] = [],
-    options?: Pick<Options, 'cwd'>
-  ) => {
-    return new ProcessController(execa(command, args, options));
+  waitForLineIncludes = (str: string) => {
+    this.expectedLineQueue.push({
+      predicate: (line) => line.includes(str),
+      thenSend: [],
+    });
+    return this;
   };
 
   send = (str: string) => {
-    this.processInterface.write(str);
+    if (this.expectedLineQueue.length === 0) {
+      throw new Error('Must wait for a line before sending');
+    }
+    this.expectedLineQueue.at(-1)?.thenSend.push(str);
     return this;
   };
 
@@ -49,29 +53,56 @@ export class ProcessController {
     return this;
   };
 
-  waitForLineIncludes = async (expected: string) => {
-    // attach a line listener that will wait until the expected line is found
-    // once found, it will pause the input stream and remove itself from the line listeners
-    const foundExpectedStringPromise = new Promise<void>((resolve) => {
-      const selfRemovingListener = (line: string) => {
-        if (line.includes(expected)) {
-          this.processInterface.pause();
-          this.processInterface.removeListener('line', selfRemovingListener);
-          resolve();
-        }
-      };
-      this.processInterface.on('line', selfRemovingListener);
-    });
+  sendNo = () => {
+    this.sendLine('N');
+    return this;
+  };
 
-    // now that the line listener is attached, we can resume the input stream
-    this.processInterface.resume();
+  sendYes = () => {
+    this.sendLine('Y');
+    return this;
+  };
 
-    // wait for the line to be found
-    await foundExpectedStringPromise;
+  sendCtrlC = () => {
+    this.send(CONTROL_C);
     return this;
   };
 
-  kill = () => {
-    this.execaProcess.kill();
+  /**
+   * Execute the sequence of actions queued on the process
+   */
+  run = async () => {
+    const execaProcess = execa(this.command, this.args, this.options);
+
+    if (process.stdout) {
+      void execaProcess.pipeStdout?.(process.stdout);
+    }
+
+    if (!execaProcess.stdout) {
+      throw new Error('Child process does not have stdout stream');
+    }
+    const reader = readline.createInterface(execaProcess.stdout);
+
+    for await (const line of reader) {
+      const expectedLine = this.expectedLineQueue[0];
+      if (!expectedLine?.predicate(line)) {
+        continue;
+      }
+      // if we got here, the line matched the predicate
+      for (const chunk of expectedLine.thenSend) {
+        if (chunk === CONTROL_C) {
+          execaProcess.kill('SIGINT');
+        } else {
+          await new Promise<void>((resolve, reject) => {
+            execaProcess.stdin?.write(chunk, (err) => {
+              return err ? reject(err) : resolve();
+            });
+          });
+        }
+      }
+      this.expectedLineQueue.shift();
+    }
+
+    await execaProcess;
   };
 }