Merge branch 'main' into komal/npm-publish

Author: komal-dhull

src/commands/__tests__/__snapshots__/ssh.test.ts.snap

@@ -0,0 +1,26 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`ssh ephemeral access should call ssm: stderr 1`] = `
+[
+  [
+    "a message",
+  ],
+  [
+    "Will wait up to 5 minutes for this request to complete...",
+  ],
+  [
+    "Your request was approved",
+  ],
+  [
+    "Waiting for access to be provisioned",
+  ],
+]
+`;
+
+exports[`ssh persistent access should call ssm: stderr 1`] = `
+[
+  [
+    "Waiting for access to be provisioned",
+  ],
+]
+`;

src/commands/__tests__/ssh.test.ts

@@ -0,0 +1,84 @@
+import { fetchCommand } from "../../drivers/api";
+import { print1, print2 } from "../../drivers/stdio";
+import { ssm } from "../../plugins/aws/ssm";
+import { mockGetDoc } from "../../testing/firestore";
+import { sleep } from "../../util";
+import { sshCommand } from "../ssh";
+import { onSnapshot } from "firebase/firestore";
+import yargs from "yargs";
+
+jest.mock("../../drivers/api");
+jest.mock("../../drivers/auth");
+jest.mock("../../drivers/stdio");
+jest.mock("../../plugins/aws/ssm");
+
+const mockFetchCommand = fetchCommand as jest.Mock;
+const mockSsm = ssm as jest.Mock;
+const mockPrint1 = print1 as jest.Mock;
+const mockPrint2 = print2 as jest.Mock;
+
+mockGetDoc({
+  workflows: {
+    items: [
+      {
+        identifier: "test-account",
+        state: "installed",
+        type: "aws",
+      },
+    ],
+  },
+});
+
+mockSsm.mockResolvedValue({});
+
+describe("ssh", () => {
+  describe.each([
+    ["persistent", true],
+    ["ephemeral", false],
+  ])("%s access", (_, isPersistent) => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+      mockFetchCommand.mockResolvedValue({
+        ok: true,
+        message: "a message",
+        id: "abcefg",
+        isPreexisting: false,
+        isPersistent,
+      });
+    });
+
+    it("should wait for access grant", async () => {
+      const promise = sshCommand(yargs()).parse(`ssh some-instance`);
+      const wait = sleep(100);
+      await Promise.race([wait, promise]);
+      await expect(wait).resolves.toBeUndefined();
+    });
+
+    it("should wait for provisioning", async () => {
+      const promise = sshCommand(yargs()).parse(`ssh some-instance`);
+      await sleep(100); // Need to wait for listen before trigger in tests
+      (onSnapshot as any).trigger({
+        status: "APPROVED",
+      });
+      const wait = sleep(100);
+      await Promise.race([wait, promise]);
+      await expect(wait).resolves.toBeUndefined();
+    });
+
+    it("should call ssm", async () => {
+      const promise = sshCommand(yargs()).parse(`ssh some-instance`);
+      await sleep(100); // Need to wait for listen before trigger in tests
+      (onSnapshot as any).trigger({
+        status: "APPROVED",
+      });
+      await sleep(100); // Need to wait for listen before trigger in tests
+      (onSnapshot as any).trigger({
+        status: "DONE",
+      });
+      await expect(promise).resolves.toBeDefined();
+      expect(mockPrint2.mock.calls).toMatchSnapshot("stderr");
+      expect(mockPrint1).not.toHaveBeenCalled();
+      expect(mockSsm).toHaveBeenCalled();
+    });
+  });
+});

src/commands/ssh.ts

@@ -77,6 +77,8 @@ const waitForProvisioning = async <P extends PluginRequest>(
         unsubscribe();
       }
     );
+    // Skip timeout in test; it holds a ref longer than the test lasts
+    if (process.env.NODE_ENV === "test") return;
     cancel = setTimeout(() => {
       if (!isResolved) {
         unsubscribe();

src/util.ts

@@ -1,5 +1,19 @@
-export const sleep = (timeoutMillis: number) =>
-  new Promise<void>((resolve) => setTimeout(resolve, timeoutMillis));
+/** Waits the specified delay (in ms)
+ *
+ * The returned promise is cancelable:
+ * ```
+ * const wait = sleep(10);
+ * ...
+ * wait.cancel();
+ * ```
+ */
+export const sleep = (timeoutMillis: number) => {
+  let timer: NodeJS.Timeout | undefined = undefined;
+  const promise = new Promise<void>((resolve) => {
+    timer = setTimeout(resolve, timeoutMillis);
+  });
+  return Object.assign(promise, { cancel: () => clearTimeout(timer) });
+};
 
 export const noop = () => {};