wrangler 0.0.13 → 0.0.17

package/src/__tests__/r2.test.ts

@@ -0,0 +1,206 @@
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
+import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import type { R2BucketInfo } from "../r2";
+
+describe("wrangler", () => {
+  mockAccountId();
+  mockApiToken();
+  runInTempDir();
+  const std = mockConsoleMethods();
+
+  afterEach(() => {
+    unsetAllMocks();
+  });
+
+  describe("r2", () => {
+    describe("bucket", () => {
+      describe("list", () => {
+        function mockListRequest(buckets: R2BucketInfo[]) {
+          const requests = { count: 0 };
+          setMockResponse(
+            "/accounts/:accountId/r2/buckets",
+            ([_url, accountId], init) => {
+              requests.count++;
+              expect(accountId).toEqual("some-account-id");
+              expect(init).toEqual({});
+              return { buckets };
+            }
+          );
+          return requests;
+        }
+
+        it("should list buckets", async () => {
+          const expectedBuckets: R2BucketInfo[] = [
+            { name: "bucket-1", creation_date: "01-01-2001" },
+            { name: "bucket-2", creation_date: "01-01-2001" },
+          ];
+          mockListRequest(expectedBuckets);
+          await runWrangler("r2 bucket list");
+
+          expect(std.err).toMatchInlineSnapshot(`""`);
+          const buckets = JSON.parse(std.out);
+          expect(buckets).toEqual(expectedBuckets);
+        });
+      });
+
+      describe("create", () => {
+        function mockCreateRequest(expectedBucketName: string) {
+          const requests = { count: 0 };
+          setMockResponse(
+            "/accounts/:accountId/r2/buckets/:bucketName",
+            "PUT",
+            ([_url, accountId, bucketName]) => {
+              expect(accountId).toEqual("some-account-id");
+              expect(bucketName).toEqual(expectedBucketName);
+              requests.count += 1;
+            }
+          );
+          return requests;
+        }
+
+        it("should error if no bucket name is given", async () => {
+          await expect(
+            runWrangler("r2 bucket create")
+          ).rejects.toThrowErrorMatchingInlineSnapshot(
+            `"Not enough non-option arguments: got 0, need at least 1"`
+          );
+          expect(std.out).toMatchInlineSnapshot(`""`);
+          expect(std.err).toMatchInlineSnapshot(`
+            "wrangler r2 bucket create <name>
+
+            Create a new R2 bucket
+
+            Positionals:
+              name  The name of the new bucket  [string] [required]
+
+            Flags:
+              -c, --config   Path to .toml configuration file  [string]
+              -h, --help     Show help  [boolean]
+              -v, --version  Show version number  [boolean]
+
+            Options:
+              -l, --local  Run on my machine  [boolean] [default: false]
+
+            Not enough non-option arguments: got 0, need at least 1"
+          `);
+        });
+
+        it("should error if the bucket to create contains spaces", async () => {
+          await expect(
+            runWrangler("r2 bucket create abc def ghi")
+          ).rejects.toThrowErrorMatchingInlineSnapshot(
+            `"Unexpected additional positional arguments \\"def ghi\\"."`
+          );
+          expect(std.out).toMatchInlineSnapshot(`""`);
+          expect(std.err).toMatchInlineSnapshot(`
+            "wrangler r2 bucket create <name>
+
+            Create a new R2 bucket
+
+            Positionals:
+              name  The name of the new bucket  [string] [required]
+
+            Flags:
+              -c, --config   Path to .toml configuration file  [string]
+              -h, --help     Show help  [boolean]
+              -v, --version  Show version number  [boolean]
+
+            Options:
+              -l, --local  Run on my machine  [boolean] [default: false]
+
+            Unexpected additional positional arguments \\"def ghi\\"."
+          `);
+        });
+
+        it("should create a bucket", async () => {
+          const requests = mockCreateRequest("testBucket");
+          await runWrangler("r2 bucket create testBucket");
+          expect(std.out).toMatchInlineSnapshot(`
+            "Creating bucket testBucket.
+            Created bucket testBucket."
+          `);
+          expect(requests.count).toEqual(1);
+        });
+      });
+
+      describe("delete", () => {
+        function mockDeleteRequest(expectedBucketName: string) {
+          const requests = { count: 0 };
+          setMockResponse(
+            "/accounts/:accountId/r2/buckets/:bucketName",
+            "DELETE",
+            ([_url, accountId, bucketName]) => {
+              expect(accountId).toEqual("some-account-id");
+              expect(bucketName).toEqual(expectedBucketName);
+              requests.count += 1;
+            }
+          );
+          return requests;
+        }
+
+        it("should error if no bucket name is given", async () => {
+          await expect(
+            runWrangler("r2 bucket delete")
+          ).rejects.toThrowErrorMatchingInlineSnapshot(
+            `"Not enough non-option arguments: got 0, need at least 1"`
+          );
+          expect(std.out).toMatchInlineSnapshot(`""`);
+          expect(std.err).toMatchInlineSnapshot(`
+            "wrangler r2 bucket delete <name>
+
+            Delete an R2 bucket
+
+            Positionals:
+              name  The name of the bucket to delete  [string] [required]
+
+            Flags:
+              -c, --config   Path to .toml configuration file  [string]
+              -h, --help     Show help  [boolean]
+              -v, --version  Show version number  [boolean]
+
+            Options:
+              -l, --local  Run on my machine  [boolean] [default: false]
+
+            Not enough non-option arguments: got 0, need at least 1"
+          `);
+        });
+
+        it("should error if the bucket name to delete contains spaces", async () => {
+          await expect(
+            runWrangler("r2 bucket delete abc def ghi")
+          ).rejects.toThrowErrorMatchingInlineSnapshot(
+            `"Unexpected additional positional arguments \\"def ghi\\"."`
+          );
+          expect(std.out).toMatchInlineSnapshot(`""`);
+          expect(std.err).toMatchInlineSnapshot(`
+            "wrangler r2 bucket delete <name>
+
+            Delete an R2 bucket
+
+            Positionals:
+              name  The name of the bucket to delete  [string] [required]
+
+            Flags:
+              -c, --config   Path to .toml configuration file  [string]
+              -h, --help     Show help  [boolean]
+              -v, --version  Show version number  [boolean]
+
+            Options:
+              -l, --local  Run on my machine  [boolean] [default: false]
+
+            Unexpected additional positional arguments \\"def ghi\\"."
+          `);
+        });
+
+        it("should delete a bucket specified by name", async () => {
+          const requests = mockDeleteRequest("some-bucket");
+          await runWrangler(`r2 bucket delete some-bucket`);
+          expect(requests.count).toEqual(1);
+        });
+      });
+    });
+  });
+});

package/src/__tests__/secret.test.ts

@@ -0,0 +1,210 @@
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
+import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { mockConfirm, mockPrompt } from "./helpers/mock-dialogs";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+
+describe("wrangler secret", () => {
+  const std = mockConsoleMethods();
+  runInTempDir();
+  mockAccountId();
+  mockApiToken();
+
+  afterEach(() => {
+    unsetAllMocks();
+  });
+
+  describe("put", () => {
+    function mockPutRequest(input: { name: string; text: string }) {
+      setMockResponse(
+        "/accounts/:accountId/workers/scripts/:scriptName/secrets",
+        "PUT",
+        ([_url, accountId], { body }) => {
+          expect(accountId).toEqual("some-account-id");
+          const { name, text, type } = JSON.parse(body as string);
+          expect(type).toEqual("secret_text");
+          expect(name).toEqual(input.name);
+          expect(text).toEqual(input.text);
+
+          return { name, type };
+        }
+      );
+    }
+
+    it("should create a secret", async () => {
+      mockPrompt({
+        text: "Enter a secret value:",
+        type: "password",
+        result: "the-secret",
+      });
+
+      mockPutRequest({ name: "the-secret-name", text: "the-secret" });
+      await runWrangler("secret put the-key --name script-name");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "🌀 Creating the secret for script script-name
+        ✨ Success! Uploaded secret the-key"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should error without a script name", async () => {
+      let error: Error | undefined;
+      try {
+        await runWrangler("secret put the-key");
+      } catch (e) {
+        error = e as Error;
+      }
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
+        "Missing script name
+
+        %s
+        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
+      expect(error).toMatchInlineSnapshot(`[Error: Missing script name]`);
+    });
+
+    it("warns about being a no-op in local mode", async () => {
+      mockPrompt({
+        text: "Enter a secret value:",
+        type: "password",
+        result: "the-secret",
+      });
+
+      mockPutRequest({ name: "the-secret-name", text: "the-secret" });
+      await runWrangler("secret put the-key --name script-name --local");
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(
+        `"\`wrangler secret put\` is a no-op in --local mode"`
+      );
+    });
+  });
+
+  describe("delete", () => {
+    function mockDeleteRequest(input: {
+      scriptName: string;
+      secretName: string;
+    }) {
+      setMockResponse(
+        "/accounts/:accountId/workers/scripts/:scriptName/secrets/:secretName",
+        "DELETE",
+        ([_url, accountId, scriptName, secretName]) => {
+          expect(accountId).toEqual("some-account-id");
+          expect(scriptName).toEqual(input.scriptName);
+          expect(secretName).toEqual(input.secretName);
+
+          return null;
+        }
+      );
+    }
+    it("should delete a secret", async () => {
+      mockDeleteRequest({ scriptName: "script-name", secretName: "the-key" });
+      mockConfirm({
+        text: "Are you sure you want to permanently delete the variable the-key on the script script-name?",
+        result: true,
+      });
+      await runWrangler("secret delete the-key --name script-name");
+      expect(std.out).toMatchInlineSnapshot(`
+        "🌀 Deleting the secret the-key on script script-name.
+        ✨ Success! Deleted secret the-key"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should error without a script name", async () => {
+      let error: Error | undefined;
+
+      try {
+        await runWrangler("secret delete the-key");
+      } catch (e) {
+        error = e as Error;
+      }
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
+        "Missing script name
+
+        %s
+        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
+      expect(error).toMatchInlineSnapshot(`[Error: Missing script name]`);
+    });
+
+    it("warns about being a no-op in local mode", async () => {
+      mockConfirm({
+        text: "Are you sure you want to permanently delete the variable the-key on the script script-name?",
+        result: true,
+      });
+      await runWrangler("secret delete the-key --name script-name --local");
+      expect(std.out).toMatchInlineSnapshot(
+        `"🌀 Deleting the secret the-key on script script-name."`
+      );
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(
+        `"\`wrangler secret delete\` is a no-op in --local mode"`
+      );
+    });
+  });
+
+  describe("list", () => {
+    function mockListRequest(input: { scriptName: string }) {
+      setMockResponse(
+        "/accounts/:accountId/workers/scripts/:scriptName/secrets",
+        "GET",
+        ([_url, accountId, scriptName]) => {
+          expect(accountId).toEqual("some-account-id");
+          expect(scriptName).toEqual(input.scriptName);
+
+          return [
+            {
+              name: "the-secret-name",
+              type: "secret_text",
+            },
+          ];
+        }
+      );
+    }
+
+    it("should list secrets", async () => {
+      mockListRequest({ scriptName: "script-name" });
+      await runWrangler("secret list --name script-name");
+      expect(std.out).toMatchInlineSnapshot(`
+        "[
+          {
+            \\"name\\": \\"the-secret-name\\",
+            \\"type\\": \\"secret_text\\"
+          }
+        ]"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should error without a script name", async () => {
+      let error: Error | undefined;
+      try {
+        await runWrangler("secret list");
+      } catch (e) {
+        error = e as Error;
+      }
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
+        "Missing script name
+
+        %s
+        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
+      expect(error).toMatchInlineSnapshot(`[Error: Missing script name]`);
+    });
+
+    it("warns about being a no-op in local mode", async () => {
+      await runWrangler("secret list --name script-name --local");
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(
+        `"\`wrangler secret list\` is a no-op in --local mode"`
+      );
+    });
+  });
+});

package/src/__tests__/sentry.test.ts

@@ -0,0 +1,146 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import * as TOML from "@iarna/toml";
+import * as Sentry from "@sentry/node";
+import prompts from "prompts";
+
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+const { reportError } = jest.requireActual("../reporting");
+
+describe("Error Reporting", () => {
+  runInTempDir({ homedir: "./home" });
+  mockConsoleMethods();
+  const reportingTOMLPath = ".wrangler/config/reporting.toml";
+
+  const originalTTY = process.stdout.isTTY;
+  beforeEach(() => {
+    jest.mock("@sentry/node");
+    jest.spyOn(Sentry, "captureException");
+    process.stdout.isTTY = true;
+  });
+
+  afterEach(() => {
+    jest.unmock("@sentry/node");
+    jest.clearAllMocks();
+    process.stdout.isTTY = originalTTY;
+  });
+
+  it("should confirm user will allow error reporting usage", async () => {
+    jest.spyOn(prompts, "prompt").mockResolvedValue({ sentryDecision: true });
+
+    await reportError(new Error("test error"), "testFalse");
+
+    const { error_tracking_opt, error_tracking_opt_date } = TOML.parse(
+      await fsp.readFile(path.join(os.homedir(), reportingTOMLPath), "utf-8")
+    );
+
+    expect(error_tracking_opt).toBe(true);
+    expect(error_tracking_opt_date).toBeTruthy();
+
+    expect(Sentry.captureException).toHaveBeenCalledWith(
+      new Error("test error")
+    );
+  });
+
+  it("should confirm user will disallow error reporting usage", async () => {
+    jest.spyOn(prompts, "prompt").mockResolvedValue({ sentryDecision: false });
+    await reportError(new Error("test error"), "testFalse");
+
+    const { error_tracking_opt, error_tracking_opt_date } = TOML.parse(
+      await fsp.readFile(path.join(os.homedir(), reportingTOMLPath), "utf-8")
+    );
+
+    expect(error_tracking_opt).toBe(false);
+    expect(error_tracking_opt_date).toBeTruthy();
+
+    expect(Sentry.captureException).not.toHaveBeenCalledWith(
+      new Error("test error"),
+      "testFalse"
+    );
+  });
+
+  it("should confirm user will allow 'once' error reporting usage", async () => {
+    jest.spyOn(prompts, "prompt").mockResolvedValue({ sentryDecision: "once" });
+    await runWrangler();
+    await reportError(new Error("test error"), "testFalse");
+
+    expect(fs.existsSync(path.join(os.homedir(), reportingTOMLPath))).toBe(
+      false
+    );
+
+    expect(Sentry.captureException).not.toHaveBeenCalledWith(
+      new Error("test error"),
+      "testFalse"
+    );
+  });
+
+  it("should not prompt w/ subsequent Errors after user disallows error reporting", async () => {
+    jest.spyOn(prompts, "prompt").mockResolvedValue({ sentryDecision: false });
+    await reportError(new Error("test error"), "testFalse");
+
+    expect(Sentry.captureException).not.toHaveBeenCalledWith(
+      new Error("test error"),
+      "testFalse"
+    );
+
+    await reportError(new Error("second test error"), "testFalse");
+    expect(Sentry.captureException).not.toHaveBeenCalledWith(
+      new Error("second test error"),
+      "testFalse"
+    );
+  });
+
+  it("should not prompt w/ subsequent Errors after user Always allows error reporting", async () => {
+    jest.spyOn(prompts, "prompt").mockResolvedValue({ sentryDecision: true });
+    await reportError(new Error("test error"), "testFalse");
+
+    expect(Sentry.captureException).toHaveBeenCalledWith(
+      new Error("test error")
+    );
+
+    await reportError(new Error("second test error"), "testFalse");
+    expect(Sentry.captureException).toHaveBeenCalledWith(
+      new Error("second test error")
+    );
+  });
+
+  it("should prompt w/ subsequent Errors after user allows error reporting once", async () => {
+    const promptSpy = jest
+      .spyOn(prompts, "prompt")
+      .mockResolvedValue({ sentryDecision: "once" });
+    await reportError(new Error("test error"), "testFalse");
+
+    expect(Sentry.captureException).toHaveBeenCalledWith(
+      new Error("test error")
+    );
+
+    await reportError(new Error("second test error"), "testFalse");
+    expect(Sentry.captureException).toHaveBeenCalledWith(
+      new Error("second test error")
+    );
+
+    expect(promptSpy).toBeCalledTimes(2);
+  });
+
+  it("should not prompt in non-TTY environment", async () => {
+    process.stdout.isTTY = false;
+
+    await reportError(new Error("test error"), "testFalse");
+
+    const { error_tracking_opt, error_tracking_opt_date } = TOML.parse(
+      await fsp.readFile(path.join(os.homedir(), reportingTOMLPath), "utf-8")
+    );
+
+    expect(error_tracking_opt).toBe(false);
+    expect(error_tracking_opt_date).toBeTruthy();
+
+    expect(Sentry.captureException).not.toHaveBeenCalledWith(
+      new Error("test error")
+    );
+    process.stdout.isTTY = originalTTY;
+  });
+});