wrangler 0.0.0-e2a26a0 → 0.0.0-e3cab74

package/src/__tests__/r2.test.ts

@@ -0,0 +1,198 @@
+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]
+                  --legacy-env  Use legacy environments  [boolean]
+
+            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]
+                  --legacy-env  Use legacy environments  [boolean]
+
+            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]
+                  --legacy-env  Use legacy environments  [boolean]
+
+            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]
+                  --legacy-env  Use legacy environments  [boolean]
+
+            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

@@ -16,12 +16,24 @@ describe("wrangler secret", () => {
   });
 
   describe("put", () => {
-    function mockPutRequest(input: { name: string; text: string }) {
+    function mockPutRequest(
+      input: { name: string; text: string },
+      env?: string,
+      legacyEnv = false
+    ) {
+      const servicesOrScripts = env && !legacyEnv ? "services" : "scripts";
+      const environment = env && !legacyEnv ? "/environments/:envName" : "";
       setMockResponse(
-        "/accounts/:accountId/workers/scripts/:scriptName/secrets",
+        `/accounts/:accountId/workers/${servicesOrScripts}/:scriptName${environment}/secrets`,
         "PUT",
-        ([_url, accountId], { body }) => {
+        ([_url, accountId, scriptName, envName], { body }) => {
           expect(accountId).toEqual("some-account-id");
+          expect(scriptName).toEqual(
+            legacyEnv && env ? `script-name-${env}` : "script-name"
+          );
+          if (!legacyEnv) {
+            expect(envName).toEqual(env);
+          }
           const { name, text, type } = JSON.parse(body as string);
           expect(type).toEqual("secret_text");
           expect(name).toEqual(input.name);
@@ -49,12 +61,58 @@ describe("wrangler secret", () => {
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
 
+    it("should create a secret: legacy envs", async () => {
+      mockPrompt({
+        text: "Enter a secret value:",
+        type: "password",
+        result: "the-secret",
+      });
+
+      mockPutRequest(
+        { name: "the-secret-name", text: "the-secret" },
+        "some-env",
+        true
+      );
+      await runWrangler(
+        "secret put the-key --name script-name --env some-env --legacy-env"
+      );
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "🌀 Creating the secret for script script-name-some-env
+        ✨ Success! Uploaded secret the-key"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should create a secret: service envs", async () => {
+      mockPrompt({
+        text: "Enter a secret value:",
+        type: "password",
+        result: "the-secret",
+      });
+
+      mockPutRequest(
+        { name: "the-secret-name", text: "the-secret" },
+        "some-env",
+        false
+      );
+      await runWrangler(
+        "secret put the-key --name script-name --env some-env --legacy-env false"
+      );
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "🌀 Creating the secret for script script-name (some-env)
+        ✨ 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;
+        error = e as Error;
       }
       expect(std.out).toMatchInlineSnapshot(`""`);
       expect(std.err).toMatchInlineSnapshot(`
@@ -65,37 +123,37 @@ describe("wrangler secret", () => {
       `);
       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;
-    }) {
+    function mockDeleteRequest(
+      input: {
+        scriptName: string;
+        secretName: string;
+      },
+      env?: string,
+      legacyEnv = false
+    ) {
+      const servicesOrScripts = env && !legacyEnv ? "services" : "scripts";
+      const environment = env && !legacyEnv ? "/environments/:envName" : "";
       setMockResponse(
-        "/accounts/:accountId/workers/scripts/:scriptName/secrets/:secretName",
+        `/accounts/:accountId/workers/${servicesOrScripts}/:scriptName${environment}/secrets/:secretName`,
         "DELETE",
-        ([_url, accountId, scriptName, secretName]) => {
+        ([_url, accountId, scriptName, envOrSecretName, secretName]) => {
           expect(accountId).toEqual("some-account-id");
-          expect(scriptName).toEqual(input.scriptName);
-          expect(secretName).toEqual(input.secretName);
-
+          expect(scriptName).toEqual(
+            legacyEnv && env ? `script-name-${env}` : "script-name"
+          );
+          if (!legacyEnv) {
+            if (env) {
+              expect(envOrSecretName).toEqual(env);
+              expect(secretName).toEqual(input.secretName);
+            } else {
+              expect(envOrSecretName).toEqual(input.secretName);
+            }
+          } else {
+            expect(envOrSecretName).toEqual(input.secretName);
+          }
           return null;
         }
       );
@@ -108,7 +166,46 @@ describe("wrangler secret", () => {
       });
       await runWrangler("secret delete the-key --name script-name");
       expect(std.out).toMatchInlineSnapshot(`
-        "🌀 Deleting the secret the-key on script script-name.
+        "🌀 Deleting the secret the-key on script script-name
+        ✨ Success! Deleted secret the-key"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should delete a secret: legacy envs", async () => {
+      mockDeleteRequest(
+        { scriptName: "script-name", secretName: "the-key" },
+        "some-env",
+        true
+      );
+      mockConfirm({
+        text: "Are you sure you want to permanently delete the variable the-key on the script script-name-some-env?",
+        result: true,
+      });
+      await runWrangler(
+        "secret delete the-key --name script-name --env some-env --legacy-env"
+      );
+      expect(std.out).toMatchInlineSnapshot(`
+        "🌀 Deleting the secret the-key on script script-name-some-env
+        ✨ Success! Deleted secret the-key"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should delete a secret: service envs", async () => {
+      mockDeleteRequest(
+        { scriptName: "script-name", secretName: "the-key" },
+        "some-env"
+      );
+      mockConfirm({
+        text: "Are you sure you want to permanently delete the variable the-key on the script script-name (some-env)?",
+        result: true,
+      });
+      await runWrangler(
+        "secret delete the-key --name script-name --env some-env --legacy-env false"
+      );
+      expect(std.out).toMatchInlineSnapshot(`
+        "🌀 Deleting the secret the-key on script script-name (some-env)
         ✨ Success! Deleted secret the-key"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
@@ -120,7 +217,7 @@ describe("wrangler secret", () => {
       try {
         await runWrangler("secret delete the-key");
       } catch (e) {
-        error = e;
+        error = e as Error;
       }
       expect(std.out).toMatchInlineSnapshot(`""`);
       expect(std.err).toMatchInlineSnapshot(`
@@ -131,31 +228,27 @@ describe("wrangler secret", () => {
       `);
       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 }) {
+    function mockListRequest(
+      input: { scriptName: string },
+      env?: string,
+      legacyEnv = false
+    ) {
+      const servicesOrScripts = env && !legacyEnv ? "services" : "scripts";
+      const environment = env && !legacyEnv ? "/environments/:envName" : "";
       setMockResponse(
-        "/accounts/:accountId/workers/scripts/:scriptName/secrets",
+        `/accounts/:accountId/workers/${servicesOrScripts}/:scriptName${environment}/secrets`,
         "GET",
-        ([_url, accountId, scriptName]) => {
+        ([_url, accountId, scriptName, envName]) => {
           expect(accountId).toEqual("some-account-id");
-          expect(scriptName).toEqual(input.scriptName);
+          expect(scriptName).toEqual(
+            legacyEnv && env ? `script-name-${env}` : "script-name"
+          );
+          if (!legacyEnv) {
+            expect(envName).toEqual(env);
+          }
 
           return [
             {
@@ -181,12 +274,44 @@ describe("wrangler secret", () => {
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
 
+    it("should list secrets: legacy envs", async () => {
+      mockListRequest({ scriptName: "script-name" }, "some-env", true);
+      await runWrangler(
+        "secret list --name script-name --env some-env --legacy-env"
+      );
+      expect(std.out).toMatchInlineSnapshot(`
+        "[
+          {
+            \\"name\\": \\"the-secret-name\\",
+            \\"type\\": \\"secret_text\\"
+          }
+        ]"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should list secrets: service envs", async () => {
+      mockListRequest({ scriptName: "script-name" }, "some-env");
+      await runWrangler(
+        "secret list --name script-name --env some-env --legacy-env false"
+      );
+      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;
+        error = e as Error;
       }
       expect(std.out).toMatchInlineSnapshot(`""`);
       expect(std.err).toMatchInlineSnapshot(`
@@ -197,14 +322,5 @@ describe("wrangler secret", () => {
       `);
       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;
+  });
+});