wrangler 0.0.0-e3cab74 → 0.0.0-e3e3243

package/src/__tests__/helpers/mock-account-id.ts

@@ -1,14 +1,25 @@
+import { reinitialiseAuthTokens } from "../../user";
+
 const ORIGINAL_CLOUDFLARE_API_TOKEN = process.env.CLOUDFLARE_API_TOKEN;
 const ORIGINAL_CLOUDFLARE_ACCOUNT_ID = process.env.CLOUDFLARE_ACCOUNT_ID;
 
 /**
  * Mock the API token so that we don't need to read it from user configuration files.
+ *
+ * Note that you can remove any API token from the environment by setting the value to `null`.
+ * This is useful if a higher `describe()` block has already called `mockApiToken()`.
  */
 export function mockApiToken({
   apiToken = "some-api-token",
-}: { apiToken?: string } = {}) {
+}: { apiToken?: string | null } = {}) {
   beforeEach(() => {
-    process.env.CLOUDFLARE_API_TOKEN = apiToken;
+    if (apiToken === null) {
+      delete process.env.CLOUDFLARE_API_TOKEN;
+    } else {
+      process.env.CLOUDFLARE_API_TOKEN = apiToken;
+    }
+    // Now we have updated the environment, we must reinitialize the user auth state.
+    reinitialiseAuthTokens();
   });
   afterEach(() => {
     process.env.CLOUDFLARE_API_TOKEN = ORIGINAL_CLOUDFLARE_API_TOKEN;
@@ -17,12 +28,19 @@ export function mockApiToken({
 
 /**
  * Mock the current account ID so that we don't need to read it from configuration files.
+ *
+ * Note that you can remove any account ID from the environment by setting the value to `null`.
+ * This is useful if a higher `describe()` block has already called `mockAccountId()`.
  */
 export function mockAccountId({
   accountId = "some-account-id",
-}: { accountId?: string } = {}) {
+}: { accountId?: string | null } = {}) {
   beforeEach(() => {
-    process.env.CLOUDFLARE_ACCOUNT_ID = accountId;
+    if (accountId === null) {
+      delete process.env.CLOUDFLARE_ACCOUNT_ID;
+    } else {
+      process.env.CLOUDFLARE_ACCOUNT_ID = accountId;
+    }
   });
   afterEach(() => {
     process.env.CLOUDFLARE_ACCOUNT_ID = ORIGINAL_CLOUDFLARE_ACCOUNT_ID;

package/src/__tests__/helpers/mock-cfetch.ts

@@ -1,7 +1,7 @@
 import { URL, URLSearchParams } from "node:url";
 import { pathToRegexp } from "path-to-regexp";
 import { getCloudflareApiBaseUrl } from "../../cfetch";
-import type { FetchResult } from "../../cfetch";
+import type { FetchResult, FetchError } from "../../cfetch";
 import type { RequestInit } from "undici";
 
 /**
@@ -143,8 +143,8 @@ export function setMockResponse<ResponseType>(
 export async function createFetchResult<ResponseType>(
   result: ResponseType | Promise<ResponseType>,
   success = true,
-  errors = [],
-  messages = [],
+  errors: FetchError[] = [],
+  messages: string[] = [],
   result_info?: unknown
 ): Promise<FetchResult<ResponseType>> {
   return result_info

package/src/__tests__/helpers/mock-console.ts

@@ -1,3 +1,5 @@
+import * as util from "node:util";
+
 /**
  * We use this module to mock console methods, and optionally
  * assert on the values they're called with in our tests.
@@ -9,22 +11,28 @@ let logSpy: jest.SpyInstance,
 
 const std = {
   get out() {
-    return stripTrailingWhitespace(
-      normalizeSlashes(stripTimings(logSpy.mock.calls.flat(2).join("\n")))
-    );
+    return normalizeOutput(logSpy);
   },
   get err() {
-    return stripTrailingWhitespace(
-      normalizeSlashes(stripTimings(errorSpy.mock.calls.flat(2).join("\n")))
-    );
+    return normalizeOutput(errorSpy);
   },
   get warn() {
-    return stripTrailingWhitespace(
-      normalizeSlashes(stripTimings(warnSpy.mock.calls.flat(2).join("\n")))
-    );
+    return normalizeOutput(warnSpy);
   },
 };
 
+function normalizeOutput(spy: jest.SpyInstance): string {
+  return stripTrailingWhitespace(
+    normalizeSlashes(stripTimings(captureCalls(spy)))
+  );
+}
+
+function captureCalls(spy: jest.SpyInstance): string {
+  return spy.mock.calls
+    .map((args: unknown[]) => util.format("%s", ...args))
+    .join("\n");
+}
+
 export function mockConsoleMethods() {
   beforeEach(() => {
     logSpy = jest.spyOn(console, "log").mockImplementation();

package/src/__tests__/helpers/mock-kv.ts

@@ -1,18 +1,15 @@
 import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
+import type { NamespaceKeyInfo } from "../../kv";
 
 export function mockKeyListRequest(
   expectedNamespaceId: string,
-  expectedKeys: string[],
+  expectedKeys: NamespaceKeyInfo[],
   keysPerRequest = 1000,
   blankCursorValue: "" | undefined | null = undefined
 ) {
   const requests = { count: 0 };
   // See https://api.cloudflare.com/#workers-kv-namespace-list-a-namespace-s-keys
-  const expectedKeyObjects = expectedKeys.map((name) => ({
-    name,
-    expiration: 123456789,
-    metadata: {},
-  }));
+
   setMockRawResponse(
     "/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
     "GET",
@@ -20,19 +17,15 @@ export function mockKeyListRequest(
       requests.count++;
       expect(accountId).toEqual("some-account-id");
       expect(namespaceId).toEqual(expectedNamespaceId);
-      if (expectedKeyObjects.length <= keysPerRequest) {
-        return createFetchResult(expectedKeyObjects);
+      if (expectedKeys.length <= keysPerRequest) {
+        return createFetchResult(expectedKeys);
       } else {
         const start = parseInt(query.get("cursor") ?? "0") || 0;
         const end = start + keysPerRequest;
-        const cursor = end < expectedKeyObjects.length ? end : blankCursorValue;
-        return createFetchResult(
-          expectedKeyObjects.slice(start, end),
-          true,
-          [],
-          [],
-          { cursor }
-        );
+        const cursor = end < expectedKeys.length ? end : blankCursorValue;
+        return createFetchResult(expectedKeys.slice(start, end), true, [], [], {
+          cursor,
+        });
       }
     }
   );

package/src/__tests__/helpers/mock-stdin.ts

@@ -0,0 +1,103 @@
+const ORIGINAL_STDIN = process.stdin;
+
+/**
+ * Mock process.stdin so that we can pipe in text for non-interactive mode tests.
+ */
+export function useMockStdin({ isTTY }: { isTTY: boolean }) {
+  const mockStdin = new MockStdIn(isTTY);
+
+  beforeEach(() => {
+    mockStdin.reset();
+    Object.defineProperty(process, "stdin", {
+      value: mockStdin,
+      configurable: true,
+      writable: false,
+    });
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, "stdin", {
+      value: ORIGINAL_STDIN,
+      configurable: true,
+      writable: false,
+    });
+  });
+
+  return mockStdin;
+}
+
+const failCallback: (value: unknown) => void = () => {
+  throw new Error(
+    "TEST FAILURE: stdin callback called before being initialized."
+  );
+};
+
+/**
+ * A mock version of `process.std`, which can be used to simulate piping data
+ * into the wrangler process in non-interactive mode.
+ */
+class MockStdIn {
+  private endCallback = failCallback;
+  private errorCallback = failCallback;
+  private chunks: string[] = [];
+  private error: Error | undefined;
+
+  /**
+   * Set this to true if you want the stdin stream to error.
+   */
+  throwError(error: Error) {
+    this.error = error;
+  }
+
+  /**
+   * Call this to clean out the chunks that are queued for sending.
+   */
+  reset() {
+    this.chunks.length = 0;
+    this.error = undefined;
+  }
+
+  /**
+   * Queue up some chunks to be sent.
+   */
+  send(...chunks: string[]) {
+    this.chunks.push(...chunks);
+  }
+
+  constructor(
+    /**
+     * Used by wrangler to check whether stdin is interactive.
+     */
+    readonly isTTY: boolean
+  ) {}
+
+  /**
+   * Used by wrangler to add event listeners.
+   */
+  on(eventName: string, callback: () => void) {
+    switch (eventName) {
+      case "readable":
+        setImmediate(callback);
+        break;
+      case "end":
+        this.endCallback = callback;
+        break;
+      case "error":
+        this.errorCallback = callback;
+        break;
+    }
+  }
+
+  /**
+   * Used by wrangler to get the next chunk of data in the stream.
+   */
+  read() {
+    if (this.error) {
+      setImmediate(() => this.errorCallback(this.error));
+    }
+    if (this.chunks.length === 0) {
+      setImmediate(this.endCallback);
+    }
+    return this.chunks.shift() ?? null;
+  }
+}

package/src/__tests__/helpers/run-in-tmp.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import os from "node:os";
 import * as path from "node:path";
+import { reinitialiseAuthTokens } from "../../user";
 
 const originalCwd = process.cwd();
 
@@ -19,6 +20,8 @@ export function runInTempDir({ homedir }: { homedir?: string } = {}) {
       // This is because the module gets transpiled so that the "method" `homedir()` gets converted to a
       // getter that is not configurable (and so cannot be spied upon).
       jest.spyOn(os, "homedir").mockReturnValue(homedir);
+      // Now that we have changed the home directory location, we must reinitialize the user auth state
+      reinitialiseAuthTokens();
     }
   });
 

package/src/__tests__/https-options.test.ts

@@ -0,0 +1,127 @@
+import fs from "node:fs";
+import os from "node:os";
+import { resolve } from "node:path";
+import { getHttpsOptions } from "../https-options";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+describe("getHttpsOptions()", () => {
+  runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
+
+  it("should use cached values if they have not expired", async () => {
+    fs.mkdirSync(resolve(os.homedir(), ".wrangler/local-cert"), {
+      recursive: true,
+    });
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      "PRIVATE KEY"
+    );
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      "PUBLIC KEY"
+    );
+    const result = await getHttpsOptions();
+    expect(result.key).toEqual("PRIVATE KEY");
+    expect(result.cert).toEqual("PUBLIC KEY");
+    expect(std.out).toMatchInlineSnapshot(`""`);
+    expect(std.warn).toMatchInlineSnapshot(`""`);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+
+  it("should generate and cache new keys if none are cached", async () => {
+    const result = await getHttpsOptions();
+    const key = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      "utf8"
+    );
+    const cert = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      "utf8"
+    );
+    expect(result.key).toEqual(key);
+    expect(result.cert).toEqual(cert);
+    expect(std.out).toMatchInlineSnapshot(
+      `"Generating new self-signed certificate..."`
+    );
+    expect(std.warn).toMatchInlineSnapshot(`""`);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+
+  it("should generate and cache new keys if cached files have expired", async () => {
+    fs.mkdirSync(resolve(os.homedir(), ".wrangler/local-cert"), {
+      recursive: true,
+    });
+    const ORIGINAL_KEY = "EXPIRED PRIVATE KEY";
+    const ORIGINAL_CERT = "EXPIRED PUBLIC KEY";
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      ORIGINAL_KEY
+    );
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      ORIGINAL_CERT
+    );
+    mockStatSync(/\.pem$/, { mtimeMs: new Date(2000).valueOf() });
+
+    const result = await getHttpsOptions();
+    const key = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      "utf8"
+    );
+    const cert = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      "utf8"
+    );
+    expect(key).not.toEqual(ORIGINAL_KEY);
+    expect(cert).not.toEqual(ORIGINAL_CERT);
+    expect(result.key).toEqual(key);
+    expect(result.cert).toEqual(cert);
+    expect(std.out).toMatchInlineSnapshot(
+      `"Generating new self-signed certificate..."`
+    );
+    expect(std.warn).toMatchInlineSnapshot(`""`);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+
+  it("should warn if not able to write to the cache", async () => {
+    mockWriteFileSyncThrow(/\.pem$/);
+    await getHttpsOptions();
+    expect(
+      fs.existsSync(resolve(os.homedir(), ".wrangler/local-cert/key.pem"))
+    ).toBe(false);
+    expect(
+      fs.existsSync(resolve(os.homedir(), ".wrangler/local-cert/cert.pem"))
+    ).toBe(false);
+    expect(std.out).toMatchInlineSnapshot(
+      `"Generating new self-signed certificate..."`
+    );
+    expect(std.warn).toMatchInlineSnapshot(`
+      "Unable to cache generated self-signed certificate in home/.wrangler/local-cert.
+      ERROR: Cannot write file"
+    `);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+});
+
+function mockStatSync(matcher: RegExp, stats: Partial<fs.Stats>) {
+  const originalStatSync = jest.requireActual("node:fs").statSync;
+  jest.spyOn(fs, "statSync").mockImplementation((statPath, options) => {
+    return matcher.test(statPath.toString())
+      ? (stats as fs.Stats)
+      : originalStatSync(statPath, options);
+  });
+}
+
+function mockWriteFileSyncThrow(matcher: RegExp) {
+  const originalWriteFileSync = jest.requireActual("node:fs").writeFileSync;
+  jest
+    .spyOn(fs, "writeFileSync")
+    .mockImplementation((filePath, data, options) => {
+      if (matcher.test(filePath.toString())) {
+        throw new Error("ERROR: Cannot write file");
+      } else {
+        return originalWriteFileSync(filePath, data, options);
+      }
+    });
+}

package/src/__tests__/index.test.ts

@@ -63,7 +63,7 @@ describe("wrangler", () => {
       await expect(
         runWrangler("invalid-command")
       ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"Unknown command: invalid-command."`
+        `"Unknown argument: invalid-command"`
       );
 
       expect(std.out).toMatchInlineSnapshot(`""`);
@@ -89,7 +89,7 @@ describe("wrangler", () => {
           -v, --version     Show version number  [boolean]
               --legacy-env  Use legacy environments  [boolean]
 
-        Unknown command: invalid-command."
+        Unknown argument: invalid-command"
       `);
     });
   });
@@ -812,14 +812,6 @@ describe("wrangler", () => {
       expect(fs.existsSync("./wrangler.toml")).toBe(true);
     });
 
-    it("should error if `--type` is used", async () => {
-      await expect(
-        runWrangler("init --type")
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"The --type option is no longer supported."`
-      );
-    });
-
     it("should error if `--type javascript` is used", async () => {
       await expect(
         runWrangler("init --type javascript")
@@ -854,7 +846,7 @@ describe("wrangler", () => {
               Try using \`wrangler dev\` to to try out a worker during development.
               "
             `);
-      await expect(runWrangler("preview GET 'Some Body'")).rejects
+      await expect(runWrangler(`preview GET "SomeBody"`)).rejects
         .toThrowErrorMatchingInlineSnapshot(`
               "DEPRECATION WARNING:
               The \`wrangler preview\` command has been deprecated.
@@ -863,4 +855,129 @@ describe("wrangler", () => {
             `);
     });
   });
+
+  describe("subcommand implicit help ran on imcomplete command execution", () => {
+    function endEventLoop() {
+      return new Promise((resolve) => setImmediate(resolve));
+    }
+    it("no subcommand for 'secret' should display a list of available subcommands", async () => {
+      await runWrangler("secret");
+      await endEventLoop();
+      expect(std.out).toMatchInlineSnapshot(`
+        "wrangler secret
+
+        🤫 Generate a secret that can be referenced in the worker script
+
+        Commands:
+          wrangler secret put <key>     Create or update a secret variable for a script
+          wrangler secret delete <key>  Delete a secret variable from a script
+          wrangler secret list          List all secrets for a script
+
+        Flags:
+          -c, --config      Path to .toml configuration file  [string]
+          -h, --help        Show help  [boolean]
+          -v, --version     Show version number  [boolean]
+              --legacy-env  Use legacy environments  [boolean]"
+      `);
+    });
+
+    it("no subcommand 'kv:namespace' should display a list of available subcommands", async () => {
+      await runWrangler("kv:namespace");
+      await endEventLoop();
+      expect(std.out).toMatchInlineSnapshot(`
+         "wrangler kv:namespace
+
+         🗂️  Interact with your Workers KV Namespaces
+
+         Commands:
+           wrangler kv:namespace create <namespace>  Create a new namespace
+           wrangler kv:namespace list                Outputs a list of all KV namespaces associated with your account id.
+           wrangler kv:namespace delete              Deletes a given namespace.
+
+         Flags:
+           -c, --config      Path to .toml configuration file  [string]
+           -h, --help        Show help  [boolean]
+           -v, --version     Show version number  [boolean]
+               --legacy-env  Use legacy environments  [boolean]"
+      `);
+    });
+
+    it("no subcommand 'kv:key' should display a list of available subcommands", async () => {
+      await runWrangler("kv:key");
+      await endEventLoop();
+      expect(std.out).toMatchInlineSnapshot(`
+               "wrangler kv:key
+
+               🔑 Individually manage Workers KV key-value pairs
+
+               Commands:
+                 wrangler kv:key put <key> [value]  Writes a single key/value pair to the given namespace.
+                 wrangler kv:key list               Outputs a list of all keys in a given namespace.
+                 wrangler kv:key get <key>          Reads a single value by key from the given namespace.
+                 wrangler kv:key delete <key>       Removes a single key value pair from the given namespace.
+
+               Flags:
+                 -c, --config      Path to .toml configuration file  [string]
+                 -h, --help        Show help  [boolean]
+                 -v, --version     Show version number  [boolean]
+                     --legacy-env  Use legacy environments  [boolean]"
+            `);
+    });
+
+    it("no subcommand 'kv:bulk' should display a list of available subcommands", async () => {
+      await runWrangler("kv:bulk");
+      await endEventLoop();
+      expect(std.out).toMatchInlineSnapshot(`
+               "wrangler kv:bulk
+
+               💪 Interact with multiple Workers KV key-value pairs at once
+
+               Commands:
+                 wrangler kv:bulk put <filename>     Upload multiple key-value pairs to a namespace
+                 wrangler kv:bulk delete <filename>  Delete multiple key-value pairs from a namespace
+
+               Flags:
+                 -c, --config      Path to .toml configuration file  [string]
+                 -h, --help        Show help  [boolean]
+                 -v, --version     Show version number  [boolean]
+                     --legacy-env  Use legacy environments  [boolean]"
+            `);
+    });
+    it("no subcommand 'r2' should display a list of available subcommands", async () => {
+      await runWrangler("r2");
+      await endEventLoop();
+      expect(std.out).toMatchInlineSnapshot(`
+               "wrangler r2
+
+               📦 Interact with an R2 store
+
+               Commands:
+                 wrangler r2 bucket  Manage R2 buckets
+
+               Flags:
+                 -c, --config      Path to .toml configuration file  [string]
+                 -h, --help        Show help  [boolean]
+                 -v, --version     Show version number  [boolean]
+                     --legacy-env  Use legacy environments  [boolean]"
+            `);
+    });
+  });
+  describe("Deprecated commands", () => {
+    it("should print a deprecation message for 'generate'", async () => {
+      await runWrangler("generate").catch((err) => {
+        expect(err.message).toMatchInlineSnapshot(`
+          "DEPRECATION WARNING:
+          \`wrangler generate\` has been deprecated, please refer to https://github.com/cloudflare/wrangler2/blob/main/docs/deprecations.md#generate for alternatives"
+        `);
+      });
+    });
+    it("should print a deprecation message for 'build'", async () => {
+      await runWrangler("build").catch((err) => {
+        expect(err.message).toMatchInlineSnapshot(`
+          "DEPRECATION WARNING:
+          \`wrangler build\` has been deprecated, please refer to https://github.com/cloudflare/wrangler2/blob/main/docs/deprecations.md#build for alternatives"
+        `);
+      });
+    });
+  });
 });

package/src/__tests__/jest.setup.ts

@@ -43,15 +43,27 @@ jest.mock("../cfetch/internal");
 jest.mock("../dialogs");
 
 // By default (if not configured by mockConfirm()) calls to `confirm()` should throw.
-(confirm as jest.Mock).mockImplementation(() => {
+(confirm as jest.Mock).mockImplementation((text: string) => {
   throw new Error(
-    "Unexpected call to `confirm()`. You should use `mockConfirm()` to mock calls to `confirm()` with expectations. Search the codebase for `mockConfirm` to learn more."
+    `Unexpected call to \`confirm("${text}")\`.\nYou should use \`mockConfirm()\` to mock calls to \`confirm()\` with expectations. Search the codebase for \`mockConfirm\` to learn more.`
   );
 });
 
 // By default (if not configured by mockPrompt()) calls to `prompt()` should throw.
-(prompt as jest.Mock).mockImplementation(() => {
+(prompt as jest.Mock).mockImplementation((text: string) => {
   throw new Error(
-    "Unexpected call to `prompt()`. You should use `mockPrompt()` to mock calls to `prompt()` with expectations. Search the codebase for `mockPrompt` to learn more."
+    `Unexpected call to \`prompt(${text}, ...)\`.\nYou should use \`mockPrompt()\` to mock calls to \`prompt()\` with expectations. Search the codebase for \`mockPrompt\` to learn more.`
   );
 });
+
+jest.mock("../dev/dev", () => {
+  const { useApp } = jest.requireActual("ink");
+  const { useEffect } = jest.requireActual("react");
+  return jest.fn().mockImplementation(() => {
+    const { exit } = useApp();
+    useEffect(() => {
+      exit();
+    });
+    return null;
+  });
+});