wrangler 0.0.0-e88a54e → 0.0.0-e95e5a0

package/src/__tests__/r2.test.ts

@@ -67,7 +67,10 @@ describe("wrangler", () => {
           ).rejects.toThrowErrorMatchingInlineSnapshot(
             `"Not enough non-option arguments: got 0, need at least 1"`
           );
-          expect(std.out).toMatchInlineSnapshot(`""`);
+          expect(std.out).toMatchInlineSnapshot(`
+            "
+            "
+          `);
           expect(std.err).toMatchInlineSnapshot(`
             "wrangler r2 bucket create <name>
 
@@ -81,8 +84,9 @@ describe("wrangler", () => {
               -h, --help        Show help  [boolean]
               -v, --version     Show version number  [boolean]
                   --legacy-env  Use legacy environments  [boolean]
+            X [ERROR] Not enough non-option arguments: got 0, need at least 1
 
-            Not enough non-option arguments: got 0, need at least 1"
+            "
           `);
         });
 
@@ -90,9 +94,12 @@ describe("wrangler", () => {
           await expect(
             runWrangler("r2 bucket create abc def ghi")
           ).rejects.toThrowErrorMatchingInlineSnapshot(
-            `"Unexpected additional positional arguments \\"def ghi\\"."`
+            `"Unknown arguments: def, ghi"`
           );
-          expect(std.out).toMatchInlineSnapshot(`""`);
+          expect(std.out).toMatchInlineSnapshot(`
+            "
+            "
+          `);
           expect(std.err).toMatchInlineSnapshot(`
             "wrangler r2 bucket create <name>
 
@@ -106,8 +113,9 @@ describe("wrangler", () => {
               -h, --help        Show help  [boolean]
               -v, --version     Show version number  [boolean]
                   --legacy-env  Use legacy environments  [boolean]
+            X [ERROR] Unknown arguments: def, ghi
 
-            Unexpected additional positional arguments \\"def ghi\\"."
+            "
           `);
         });
 
@@ -143,7 +151,10 @@ describe("wrangler", () => {
           ).rejects.toThrowErrorMatchingInlineSnapshot(
             `"Not enough non-option arguments: got 0, need at least 1"`
           );
-          expect(std.out).toMatchInlineSnapshot(`""`);
+          expect(std.out).toMatchInlineSnapshot(`
+            "
+            "
+          `);
           expect(std.err).toMatchInlineSnapshot(`
             "wrangler r2 bucket delete <name>
 
@@ -157,8 +168,9 @@ describe("wrangler", () => {
               -h, --help        Show help  [boolean]
               -v, --version     Show version number  [boolean]
                   --legacy-env  Use legacy environments  [boolean]
+            X [ERROR] Not enough non-option arguments: got 0, need at least 1
 
-            Not enough non-option arguments: got 0, need at least 1"
+            "
           `);
         });
 
@@ -166,9 +178,12 @@ describe("wrangler", () => {
           await expect(
             runWrangler("r2 bucket delete abc def ghi")
           ).rejects.toThrowErrorMatchingInlineSnapshot(
-            `"Unexpected additional positional arguments \\"def ghi\\"."`
+            `"Unknown arguments: def, ghi"`
           );
-          expect(std.out).toMatchInlineSnapshot(`""`);
+          expect(std.out).toMatchInlineSnapshot(`
+            "
+            "
+          `);
           expect(std.err).toMatchInlineSnapshot(`
             "wrangler r2 bucket delete <name>
 
@@ -182,8 +197,9 @@ describe("wrangler", () => {
               -h, --help        Show help  [boolean]
               -v, --version     Show version number  [boolean]
                   --legacy-env  Use legacy environments  [boolean]
+            X [ERROR] Unknown arguments: def, ghi
 
-            Unexpected additional positional arguments \\"def ghi\\"."
+            "
           `);
         });
 

package/src/__tests__/route.test.ts

@@ -9,7 +9,7 @@ describe("wrangler route", () => {
   it("shows a deprecation notice when `wrangler route` is run", async () => {
     await expect(runWrangler("route")).rejects
       .toThrowErrorMatchingInlineSnapshot(`
-            "DEPRECATION WARNING:
+            "Deprecation:
             \`wrangler route\` has been deprecated.
             Please use wrangler.toml and/or \`wrangler publish --routes\` to modify routes"
           `);
@@ -18,7 +18,7 @@ describe("wrangler route", () => {
   it("shows a deprecation notice when `wrangler route delete` is run", async () => {
     await expect(runWrangler("route delete")).rejects
       .toThrowErrorMatchingInlineSnapshot(`
-            "DEPRECATION WARNING:
+            "Deprecation:
             \`wrangler route delete\` has been deprecated.
             Remove the unwanted route(s) from wrangler.toml and run \`wrangler publish\` to remove your worker from those routes."
           `);
@@ -27,7 +27,7 @@ describe("wrangler route", () => {
   it("shows a deprecation notice when `wrangler route delete <id>` is run", async () => {
     await expect(runWrangler("route delete some-zone-id")).rejects
       .toThrowErrorMatchingInlineSnapshot(`
-            "DEPRECATION WARNING:
+            "Deprecation:
             \`wrangler route delete\` has been deprecated.
             Remove the unwanted route(s) from wrangler.toml and run \`wrangler publish\` to remove your worker from those routes."
           `);
@@ -36,7 +36,7 @@ describe("wrangler route", () => {
   it("shows a deprecation notice when `wrangler route list` is run", async () => {
     await expect(runWrangler("route list")).rejects
       .toThrowErrorMatchingInlineSnapshot(`
-            "DEPRECATION WARNING:
+            "Deprecation:
             \`wrangler route list\` has been deprecated.
             Refer to wrangler.toml for a list of routes the worker will be deployed to upon publishing.
             Refer to the Cloudflare Dashboard to see the routes this worker is currently running on."

package/src/__tests__/secret.test.ts

@@ -1,22 +1,31 @@
 import * as fs from "node:fs";
 import * as TOML from "@iarna/toml";
-import fetchMock from "jest-fetch-mock";
 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 {
+  mockConfirm,
+  mockPrompt,
+  clearConfirmMocks,
+  clearPromptMocks,
+} from "./helpers/mock-dialogs";
+import { mockOAuthFlow } from "./helpers/mock-oauth-flow";
 import { useMockStdin } from "./helpers/mock-stdin";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 
 describe("wrangler secret", () => {
   const std = mockConsoleMethods();
+  const { mockGetMemberships } = mockOAuthFlow();
+
   runInTempDir();
   mockAccountId();
   mockApiToken();
 
   afterEach(() => {
     unsetAllMocks();
+    clearConfirmMocks();
+    clearPromptMocks();
   });
 
   describe("put", () => {
@@ -121,11 +130,14 @@ describe("wrangler secret", () => {
         } catch (e) {
           error = e as Error;
         }
-        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        `);
         expect(std.err).toMatchInlineSnapshot(`
-          "Missing script name
+          "X [ERROR] 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]`);
       });
@@ -155,7 +167,10 @@ describe("wrangler secret", () => {
           runWrangler("secret put the-key --name script-name")
         ).rejects.toThrowErrorMatchingInlineSnapshot(`"Error in stdin stream"`);
 
-        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        `);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
 
@@ -163,10 +178,14 @@ describe("wrangler secret", () => {
         mockAccountId({ accountId: null });
 
         it("should error if a user has no account", async () => {
+          mockGetMemberships({
+            success: false,
+            result: [],
+          });
           await expect(
             runWrangler("secret put the-key --name script-name")
           ).rejects.toThrowErrorMatchingInlineSnapshot(
-            `"No account id found, quitting..."`
+            `"Failed to automatically retrieve account IDs for the logged in user. In a non-interactive environment, it is mandatory to specify an account ID, either by assigning its value to CLOUDFLARE_ACCOUNT_ID, or as \`account_id\` in your \`wrangler.toml\` file."`
           );
         });
 
@@ -190,28 +209,24 @@ describe("wrangler secret", () => {
         });
 
         it("should error if a user has multiple accounts, and has not specified an account in wrangler.toml", async () => {
-          // This is a mock response for the request to the CF API memberships of the current user.
-          fetchMock.doMockOnce(async () => {
-            return {
-              body: JSON.stringify({
-                success: true,
-                result: [
-                  {
-                    id: "1",
-                    account: { id: "account-id-1", name: "account-name-1" },
-                  },
-                  {
-                    id: "2",
-                    account: { id: "account-id-2", name: "account-name-2" },
-                  },
-                  {
-                    id: "3",
-                    account: { id: "account-id-3", name: "account-name-3" },
-                  },
-                ],
-              }),
-            };
+          mockGetMemberships({
+            success: true,
+            result: [
+              {
+                id: "1",
+                account: { id: "account-id-1", name: "account-name-1" },
+              },
+              {
+                id: "2",
+                account: { id: "account-id-2", name: "account-name-2" },
+              },
+              {
+                id: "3",
+                account: { id: "account-id-3", name: "account-name-3" },
+              },
+            ],
           });
+
           await expect(runWrangler("secret put the-key --name script-name"))
             .rejects.toThrowErrorMatchingInlineSnapshot(`
                   "More than one account available but unable to select one in non-interactive mode.
@@ -320,11 +335,14 @@ describe("wrangler secret", () => {
       } catch (e) {
         error = e as Error;
       }
-      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.out).toMatchInlineSnapshot(`
+        "
+        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
       expect(std.err).toMatchInlineSnapshot(`
-        "Missing script name
+        "X [ERROR] 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]`);
     });
@@ -413,11 +431,14 @@ describe("wrangler secret", () => {
       } catch (e) {
         error = e as Error;
       }
-      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.out).toMatchInlineSnapshot(`
+        "
+        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
       expect(std.err).toMatchInlineSnapshot(`
-        "Missing script name
+        "X [ERROR] 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]`);
     });

package/src/__tests__/tail.test.ts

@@ -3,6 +3,7 @@ import { Headers, Request } from "undici";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import type { TailEventMessage, RequestEvent, ScheduledEvent } from "../tail";
@@ -134,7 +135,7 @@ describe("tail", () => {
 
     it("sends header filters without a query", async () => {
       const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --header X-CUSTOM-HEADER ");
+      await runWrangler("tail test-worker --header X-CUSTOM-HEADER");
       await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
         { header: { key: "X-CUSTOM-HEADER" } },
       ]);
@@ -142,9 +143,7 @@ describe("tail", () => {
 
     it("sends header filters with a query", async () => {
       const api = mockWebsocketAPIs();
-      await runWrangler(
-        "tail test-worker --header X-CUSTOM-HEADER:some-value "
-      );
+      await runWrangler("tail test-worker --header X-CUSTOM-HEADER:some-value");
       await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
         { header: { key: "X-CUSTOM-HEADER", query: "some-value" } },
       ]);
@@ -218,6 +217,8 @@ describe("tail", () => {
   });
 
   describe("printing", () => {
+    const { setIsTTY } = useMockIsTTY();
+
     it("logs request messages in JSON format", async () => {
       const api = mockWebsocketAPIs();
       await runWrangler("tail test-worker --format json");
@@ -262,7 +263,7 @@ describe("tail", () => {
             "[mock expiration date]"
           )
       ).toMatchInlineSnapshot(`
-        "successfully created tail, expires at [mock expiration date]
+        "Successfully created tail, expires at [mock expiration date]
         Connected to test-worker, waiting for logs...
         GET https://example.org/ - Ok @ [mock event timestamp]"
       `);
@@ -288,11 +289,131 @@ describe("tail", () => {
             "[mock expiration date]"
           )
       ).toMatchInlineSnapshot(`
-        "successfully created tail, expires at [mock expiration date]
+        "Successfully created tail, expires at [mock expiration date]
         Connected to test-worker, waiting for logs...
         \\"* * * * *\\" @ [mock timestamp string] - Ok"
       `);
     });
+
+    it("should not crash when the tail message has a void event", async () => {
+      const api = mockWebsocketAPIs();
+      await runWrangler("tail test-worker --format pretty");
+
+      const message = generateMockEventMessage({ event: null });
+      const serializedMessage = serialize(message);
+
+      api.ws.send(serializedMessage);
+      expect(
+        std.out
+          .replace(
+            new Date(mockEventTimestamp).toLocaleString(),
+            "[mock timestamp string]"
+          )
+          .replace(
+            mockTailExpiration.toLocaleString(),
+            "[mock expiration date]"
+          )
+      ).toMatchInlineSnapshot(`
+        "Successfully created tail, expires at [mock expiration date]
+        Connected to test-worker, waiting for logs...
+        [missing request] - Ok @ [mock timestamp string]"
+      `);
+    });
+
+    it("defaults to logging in pretty format when the output is a TTY", async () => {
+      setIsTTY(true);
+      const api = mockWebsocketAPIs();
+      await runWrangler("tail test-worker");
+
+      const event = generateMockRequestEvent();
+      const message = generateMockEventMessage({ event });
+      const serializedMessage = serialize(message);
+
+      api.ws.send(serializedMessage);
+      expect(
+        std.out
+          .replace(
+            new Date(mockEventTimestamp).toLocaleString(),
+            "[mock event timestamp]"
+          )
+          .replace(
+            mockTailExpiration.toLocaleString(),
+            "[mock expiration date]"
+          )
+      ).toMatchInlineSnapshot(`
+        "Successfully created tail, expires at [mock expiration date]
+        Connected to test-worker, waiting for logs...
+        GET https://example.org/ - Ok @ [mock event timestamp]"
+      `);
+    });
+
+    it("defaults to logging in json format when the output is not a TTY", async () => {
+      setIsTTY(false);
+
+      const api = mockWebsocketAPIs();
+      await runWrangler("tail test-worker");
+
+      const event = generateMockRequestEvent();
+      const message = generateMockEventMessage({ event });
+      const serializedMessage = serialize(message);
+
+      api.ws.send(serializedMessage);
+      expect(std.out).toMatch(deserializeToJson(serializedMessage));
+    });
+
+    it("logs console messages and exceptions", async () => {
+      setIsTTY(true);
+      const api = mockWebsocketAPIs();
+      await runWrangler("tail test-worker");
+
+      const event = generateMockRequestEvent();
+      const message = generateMockEventMessage({
+        event,
+        logs: [
+          { message: ["some string"], level: "log", timestamp: 1234561 },
+          {
+            message: [{ complex: "object" }],
+            level: "log",
+            timestamp: 1234562,
+          },
+          { message: [1234], level: "error", timestamp: 1234563 },
+        ],
+        exceptions: [
+          { name: "Error", message: "some error", timestamp: 1234564 },
+          { name: "Error", message: { complex: "error" }, timestamp: 1234564 },
+        ],
+      });
+      const serializedMessage = serialize(message);
+
+      api.ws.send(serializedMessage);
+      expect(
+        std.out
+          .replace(
+            new Date(mockEventTimestamp).toLocaleString(),
+            "[mock event timestamp]"
+          )
+          .replace(
+            mockTailExpiration.toLocaleString(),
+            "[mock expiration date]"
+          )
+      ).toMatchInlineSnapshot(`
+        "Successfully created tail, expires at [mock expiration date]
+        Connected to test-worker, waiting for logs...
+        GET https://example.org/ - Ok @ [mock event timestamp]
+          (log) some string
+          (log) { complex: 'object' }
+          (error) 1234"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`
+        "X [ERROR]   Error: some error
+
+
+        X [ERROR]   Error: { complex: 'error' }
+
+        "
+      `);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
   });
 });
 
@@ -318,7 +439,8 @@ function serialize(message: TailEventMessage): WebSocket.RawData {
     // This isn't a problem outside of testing since deserialization
     // works just fine and wrangler never _sends_ any event messages,
     // it only receives them.
-    const request = (message.event as RequestEvent).request;
+    const request = ((message.event as RequestEvent | undefined | null) || {})
+      .request;
     const stringified = JSON.stringify(message, (key, value) => {
       if (key !== "request") {
         return value;
@@ -326,9 +448,9 @@ function serialize(message: TailEventMessage): WebSocket.RawData {
 
       return {
         ...request,
-        url: request.url,
-        headers: request.headers,
-        method: request.method,
+        url: request?.url,
+        headers: request?.headers,
+        method: request?.method,
       };
     });
 
@@ -343,9 +465,9 @@ function serialize(message: TailEventMessage): WebSocket.RawData {
  * @returns whether event is a ScheduledEvent (true) or a RequestEvent
  */
 function isScheduled(
-  event: ScheduledEvent | RequestEvent
+  event: ScheduledEvent | RequestEvent | undefined | null
 ): event is ScheduledEvent {
-  return "cron" in event;
+  return Boolean(event && "cron" in event);
 }
 
 /**
@@ -511,15 +633,19 @@ function mockWebsocketAPIs(env?: string, legacyEnv = false): MockAPI {
  * @param opts Any specific parts of the message to use instead of defaults
  * @returns a `TailEventMessage` that wrangler can process and display
  */
-function generateMockEventMessage(
-  opts?: Partial<TailEventMessage>
-): TailEventMessage {
+function generateMockEventMessage({
+  outcome = "ok",
+  exceptions = [],
+  logs = [],
+  eventTimestamp = mockEventTimestamp,
+  event = generateMockRequestEvent(),
+}: Partial<TailEventMessage>): TailEventMessage {
   return {
-    outcome: opts?.outcome || "ok",
-    exceptions: opts?.exceptions || [],
-    logs: opts?.logs || [],
-    eventTimestamp: opts?.eventTimestamp || mockEventTimestamp,
-    event: opts?.event || generateMockRequestEvent(),
+    outcome,
+    exceptions,
+    logs,
+    eventTimestamp,
+    event,
   };
 }
 

package/src/__tests__/user.test.ts

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import fetchMock from "jest-fetch-mock";
+import {
+  readAuthConfigFile,
+  requireAuth,
+  USER_AUTH_CONFIG_FILE,
+  writeAuthConfigFile,
+} from "../user";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
+import { mockOAuthFlow } from "./helpers/mock-oauth-flow";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import type { Config } from "../config";
+import type { UserAuthConfig } from "../user";
+
+describe("User", () => {
+  runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
+  const {
+    mockOAuthServerCallback,
+    mockGrantAccessToken,
+    mockGrantAuthorization,
+    mockRevokeAuthorization,
+    mockExchangeRefreshTokenForAccessToken,
+  } = mockOAuthFlow();
+
+  const { setIsTTY } = useMockIsTTY();
+
+  describe("login", () => {
+    it("should login a user when `wrangler login` is run", async () => {
+      mockOAuthServerCallback();
+      const accessTokenRequest = mockGrantAccessToken({ respondWith: "ok" });
+      mockGrantAuthorization({ respondWith: "success" });
+
+      await runWrangler("login");
+
+      expect(accessTokenRequest.actual.url).toEqual(
+        accessTokenRequest.expected.url
+      );
+      expect(accessTokenRequest.actual.method).toEqual(
+        accessTokenRequest.expected.method
+      );
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Attempting to login via OAuth...
+        Successfully logged in."
+      `);
+
+      expect(readAuthConfigFile()).toEqual<UserAuthConfig>({
+        api_token: undefined,
+        oauth_token: "test-access-token",
+        refresh_token: "test-refresh-token",
+        expiration_time: expect.any(String),
+      });
+    });
+  });
+
+  describe("logout", () => {
+    it("should exit with a message stating the user is not logged in", async () => {
+      await runWrangler("logout");
+      expect(std.out).toMatchInlineSnapshot(`"Not logged in, exiting..."`);
+    });
+
+    it("should logout user that has been properly logged in", async () => {
+      writeAuthConfigFile({
+        oauth_token: "some-oauth-tok",
+        refresh_token: "some-refresh-tok",
+      });
+      const outcome = mockRevokeAuthorization();
+
+      await runWrangler("logout");
+
+      expect(outcome.actual.url).toEqual(
+        "https://dash.cloudflare.com/oauth2/revoke"
+      );
+      expect(outcome.actual.method).toEqual("POST");
+
+      expect(std.out).toMatchInlineSnapshot(`"Successfully logged out."`);
+
+      // Make sure that we made the request to logout.
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+
+      // Make sure that logout removed the config file containing the auth tokens.
+      const config = path.join(os.homedir(), USER_AUTH_CONFIG_FILE);
+      expect(fs.existsSync(config)).toBeFalsy();
+    });
+  });
+
+  // TODO: Improve OAuth mocking to handle `/token` endpoints from different calls
+  it("should handle errors for failed token refresh", async () => {
+    setIsTTY(false);
+    mockOAuthServerCallback();
+    writeAuthConfigFile({
+      oauth_token: "hunter2",
+      refresh_token: "Order 66",
+    });
+    mockGrantAuthorization({ respondWith: "success" });
+
+    mockExchangeRefreshTokenForAccessToken({
+      respondWith: "badResponse",
+    });
+
+    // Handles the requireAuth error throw from failed login that is unhandled due to directly calling it here
+    await expect(
+      requireAuth({} as Config)
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `"Did not login, quitting..."`
+    );
+  });
+
+  it("should confirm no error message when refresh is successful", async () => {
+    setIsTTY(false);
+    mockOAuthServerCallback();
+    writeAuthConfigFile({
+      oauth_token: "hunter2",
+      refresh_token: "Order 66",
+    });
+    mockGrantAuthorization({ respondWith: "success" });
+
+    mockExchangeRefreshTokenForAccessToken({
+      respondWith: "refreshSuccess",
+    });
+
+    // Handles the requireAuth error throw from failed login that is unhandled due to directly calling it here
+    await expect(requireAuth({} as Config)).rejects.toThrowError();
+    expect(std.err).toContain("");
+  });
+});