wrangler 0.0.0-e61907d → 0.0.0-e95bea2

package/src/__tests__/logout.test.ts

@@ -0,0 +1,50 @@
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import fetchMock from "jest-fetch-mock";
+import { initialise } from "../user";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { writeUserConfig } from "./helpers/mock-user";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+
+describe("wrangler", () => {
+  runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
+
+  describe("logout", () => {
+    it("should exit with a message stating the user is not logged in", async () => {
+      await initialise();
+      await runWrangler("logout");
+      expect(std.out).toMatchInlineSnapshot(`"Not logged in, exiting..."`);
+    });
+
+    it("should logout user that has been properly logged in", async () => {
+      writeUserConfig("some-oauth-tok", "some-refresh-tok");
+
+      // Mock out the response for a request to revoke the auth tokens,
+      // checking the form of the request is as expected.
+      fetchMock.mockResponseOnce(async (req) => {
+        expect(req.url).toEqual("https://dash.cloudflare.com/oauth2/revoke");
+        expect(req.method).toEqual("POST");
+        return "";
+      });
+
+      await initialise();
+      await runWrangler("logout");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "💁  Wrangler is configured with an OAuth token. The token has been successfully revoked
+        Removing ./home/.wrangler/config/default.toml.. success!"
+      `);
+
+      // 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.
+      expect(
+        existsSync(path.join(os.homedir(), ".wrangler/config/default.toml"))
+      ).toBe(false);
+    });
+  });
+});

package/src/__tests__/package-manager.test.ts

@@ -0,0 +1,206 @@
+import { writeFileSync } from "node:fs";
+import { mockBinary } from "./helpers/mock-bin";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+const { getPackageManager, getPackageManagerName } =
+  jest.requireActual("../package-manager");
+interface TestCase {
+  npm: boolean;
+  yarn: boolean;
+  npmLockFile: boolean;
+  yarnLockFile: boolean;
+  expectedPackageManager: string;
+}
+
+const testCases: TestCase[] = [
+  // npm binary - no yarn binary
+  {
+    npm: true,
+    yarn: false,
+    npmLockFile: false,
+    yarnLockFile: false,
+    expectedPackageManager: "npm",
+  },
+  {
+    npm: true,
+    yarn: false,
+    npmLockFile: true,
+    yarnLockFile: false,
+    expectedPackageManager: "npm",
+  },
+  {
+    npm: true,
+    yarn: false,
+    npmLockFile: false,
+    yarnLockFile: true,
+    expectedPackageManager: "npm",
+  },
+  {
+    npm: true,
+    yarn: false,
+    npmLockFile: true,
+    yarnLockFile: true,
+    expectedPackageManager: "npm",
+  },
+
+  // yarn binary - no npm binary
+  {
+    npm: false,
+    yarn: true,
+    npmLockFile: false,
+    yarnLockFile: false,
+    expectedPackageManager: "yarn",
+  },
+  {
+    npm: false,
+    yarn: true,
+    npmLockFile: true,
+    yarnLockFile: false,
+    expectedPackageManager: "yarn",
+  },
+  {
+    npm: false,
+    yarn: true,
+    npmLockFile: false,
+    yarnLockFile: true,
+    expectedPackageManager: "yarn",
+  },
+  {
+    npm: false,
+    yarn: true,
+    npmLockFile: true,
+    yarnLockFile: true,
+    expectedPackageManager: "yarn",
+  },
+
+  // npm and yarn binaries
+  {
+    npm: true,
+    yarn: true,
+    npmLockFile: false,
+    yarnLockFile: false,
+    expectedPackageManager: "npm",
+  },
+  {
+    npm: true,
+    yarn: true,
+    npmLockFile: true,
+    yarnLockFile: false,
+    expectedPackageManager: "npm",
+  },
+  {
+    npm: true,
+    yarn: true,
+    npmLockFile: false,
+    yarnLockFile: true,
+    expectedPackageManager: "yarn",
+  },
+  {
+    npm: true,
+    yarn: true,
+    npmLockFile: true,
+    yarnLockFile: true,
+    expectedPackageManager: "npm",
+  },
+];
+
+describe("getPackageManager()", () => {
+  runInTempDir();
+  mockConsoleMethods();
+
+  describe("no supported package manager", () => {
+    mockYarn(false);
+    mockNpm(false);
+
+    it("should throw an error", async () => {
+      await expect(() =>
+        getPackageManager(process.cwd())
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Unable to find a package manager. Supported managers are: npm and yarn."`
+      );
+    });
+  });
+
+  for (const {
+    npm,
+    yarn,
+    npmLockFile,
+    yarnLockFile,
+    expectedPackageManager,
+  } of testCases) {
+    describe(
+      getTestCaseDescription(npm, yarn, npmLockFile, yarnLockFile),
+      () => {
+        mockYarn(yarn);
+        mockNpm(npm);
+        mockLockFiles(npmLockFile, yarnLockFile);
+
+        it(`should return the ${expectedPackageManager} package manager`, async () => {
+          const actualPackageManager = await getPackageManager(process.cwd());
+          expect(getPackageManagerName(actualPackageManager)).toEqual(
+            expectedPackageManager
+          );
+        });
+      }
+    );
+  }
+});
+
+/**
+ * Create a fake yarn binary
+ */
+function mockYarn(succeed: boolean): void {
+  let unMock: () => void;
+  beforeEach(async () => {
+    unMock = await mockBinary("yarn", `process.exit(${succeed ? 0 : 1})`);
+  });
+  afterEach(() => unMock());
+}
+
+/**
+ * Create a fake npm binary
+ */
+function mockNpm(succeed: boolean): void {
+  let unMock: () => void;
+  beforeEach(async () => {
+    unMock = await mockBinary("npm", `process.exit(${succeed ? 0 : 1})`);
+  });
+  afterEach(() => unMock());
+}
+
+/**
+ * Create a fake lock files.
+ */
+function mockLockFiles(npmLockFile: boolean, yarnLockFile: boolean) {
+  beforeEach(() => {
+    if (npmLockFile) {
+      writeFileSync("package-lock.json", "");
+    }
+    if (yarnLockFile) {
+      writeFileSync("yarn.lock", "");
+    }
+  });
+}
+
+function getTestCaseDescription(
+  npm: boolean,
+  yarn: boolean,
+  npmLockFile: boolean,
+  yarnLockFile: boolean
+): string {
+  const criteria: string[] = [];
+  if (npm) {
+    criteria.push("npm");
+  }
+  if (npmLockFile) {
+    criteria.push("package-lock.json");
+  }
+  if (yarn) {
+    criteria.push("yarn");
+  }
+  if (yarnLockFile) {
+    criteria.push("yarn.lock");
+  }
+  return "using " + criteria.join("; ");
+}

package/src/__tests__/pages.test.ts

@@ -0,0 +1,44 @@
+import { getPackageManager } from "../package-manager";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import type { PackageManager } from "../package-manager";
+
+describe("subcommand implicit help ran on imcomplete command execution", () => {
+  let mockPackageManager: PackageManager;
+  runInTempDir();
+
+  beforeEach(() => {
+    mockPackageManager = {
+      cwd: process.cwd(),
+      // @ts-expect-error we're making a fake package manager here
+      type: "mockpm",
+      addDevDeps: jest.fn(),
+      install: jest.fn(),
+    };
+    (getPackageManager as jest.Mock).mockResolvedValue(mockPackageManager);
+  });
+
+  const std = mockConsoleMethods();
+  function endEventLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+  }
+  it("no subcommand for 'pages' should display a list of available subcommands", async () => {
+    await runWrangler("pages");
+    await endEventLoop();
+    expect(std.out).toMatchInlineSnapshot(`
+    "wrangler pages
+
+    ⚡️ Configure Cloudflare Pages
+
+    Commands:
+      wrangler pages dev [directory] [-- command]  🧑‍💻 Develop your full-stack Pages application locally
+
+    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]"
+    `);
+  });
+});

package/src/__tests__/parse.test.ts

@@ -0,0 +1,322 @@
+import {
+  formatMessage,
+  searchLocation,
+  indexLocation,
+  parseJSON,
+  parseTOML,
+} from "../parse";
+import type { Message } from "../parse";
+
+describe("formatMessage", () => {
+  const format = (input: Message) => {
+    // No color and skip emojis at the start.
+    return formatMessage(input, false).substring(2);
+  };
+
+  it("should format message without location", () => {
+    expect(
+      format({
+        text: "Invalid argument",
+        kind: "warning",
+      })
+    ).toMatchInlineSnapshot(`
+      "[WARNING] Invalid argument
+
+      "
+    `);
+  });
+
+  it("should format message with location", () => {
+    expect(
+      format({
+        text: "Missing property: main",
+        location: {
+          line: 1,
+          column: 0,
+          lineText: "{}",
+          file: "package.json",
+          fileText: "{}",
+        },
+      })
+    ).toMatchInlineSnapshot(`
+      "[ERROR] Missing property: main
+
+          package.json:1:0:
+            1 │ {}
+              ╵ ^
+
+      "
+    `);
+  });
+
+  it("should format message with location and notes", () => {
+    expect(
+      format({
+        text: "Invalid property: type",
+        location: {
+          line: 3,
+          column: 8,
+          length: 7,
+          lineText: "type = 'modular'",
+          suggestion: "Did you mean 'module'?",
+          file: "package.toml",
+          fileText: "[package]\ntype = 'modular'\n",
+        },
+        notes: [
+          {
+            text: "There are two acceptable types: 'module' and 'commonjs'",
+          },
+        ],
+      })
+    ).toMatchInlineSnapshot(`
+      "[ERROR] Invalid property: type
+
+          package.toml:3:8:
+            3 │ type = 'modular'
+              │         ~~~~~~~
+              ╵         Did you mean 'module'?
+
+        There are two acceptable types: 'module' and 'commonjs'
+
+      "
+    `);
+  });
+});
+
+describe("parseTOML", () => {
+  it("should parse toml that is empty", () => {
+    expect(parseTOML("")).toStrictEqual({});
+  });
+
+  it("should parse toml with basic values", () => {
+    expect(
+      parseTOML(`
+        name = "basic"
+        version = 1
+    `)
+    ).toStrictEqual({
+      name: "basic",
+      version: 1,
+    });
+  });
+
+  it("should parse toml with complex values", () => {
+    expect(
+      parseTOML(`
+        name = 'complex'
+        version = 1
+        [owner]
+        name = ["tim"]
+        alive = true
+        [owner.dog]
+        exists = true
+      `)
+    ).toStrictEqual({
+      name: "complex",
+      owner: {
+        alive: true,
+        dog: {
+          exists: true,
+        },
+        name: ["tim"],
+      },
+      version: 1,
+    });
+  });
+
+  it("should fail to parse toml with invalid string", () => {
+    try {
+      parseTOML(`name = 'fail"`);
+      fail("parseTOML did not throw");
+    } catch (err) {
+      expect({ ...(err as Error) }).toStrictEqual({
+        name: "ParseError",
+        text: "Unterminated string",
+        kind: "error",
+        location: {
+          line: 1,
+          column: 14,
+          fileText: "name = 'fail\"",
+          file: undefined,
+          lineText: "name = 'fail\"",
+        },
+        notes: [],
+      });
+    }
+  });
+
+  it("should fail to parse toml with invalid header", () => {
+    try {
+      parseTOML(`\n[name`, "config.toml");
+      fail("parseTOML did not throw");
+    } catch (err) {
+      expect({ ...(err as Error) }).toStrictEqual({
+        name: "ParseError",
+        text: "Key ended without value",
+        kind: "error",
+        location: {
+          line: 2,
+          column: 5,
+          lineText: "[name",
+          file: "config.toml",
+          fileText: "\n[name",
+        },
+        notes: [],
+      });
+    }
+  });
+});
+
+describe("parseJSON", () => {
+  it("should parse json that is empty", () => {
+    expect(parseJSON("{}")).toStrictEqual({});
+  });
+
+  it("should parse json with basic values", () => {
+    expect(
+      parseJSON(`
+      {
+        "name" : "basic",
+        "version": 1
+      }`)
+    ).toStrictEqual({
+      name: "basic",
+      version: 1,
+    });
+  });
+
+  it("should parse json with complex values", () => {
+    expect(
+      parseJSON(
+        `{
+          "name":"complex",
+          "spec":{
+            "uptime":[1,2.5,3],
+            "ok":true
+          }
+        }`
+      )
+    ).toStrictEqual({
+      name: "complex",
+      spec: {
+        uptime: [1, 2.5, 3],
+        ok: true,
+      },
+    });
+  });
+
+  it("should fail to parse json with invalid string", () => {
+    try {
+      parseJSON(`\n{\n"version" "1\n}\n`);
+      fail("parseJSON did not throw");
+    } catch (err) {
+      expect({ ...(err as Error) }).toStrictEqual({
+        name: "ParseError",
+        text: "Unexpected string",
+        kind: "error",
+        location: {
+          line: 3,
+          column: 9,
+          lineText: '"version" "1',
+          file: undefined,
+          fileText: `\n{\n"version" "1\n}\n`,
+        },
+        notes: [],
+      });
+    }
+  });
+
+  it("should fail to parse json with invalid number", () => {
+    const file = "config.json",
+      fileText = `{\n\t"a":{\n\t\t"b":{\n\t\t\t"c":[012345]\n}\n}\n}`;
+    try {
+      parseJSON(fileText, file);
+      fail("parseJSON did not throw");
+    } catch (err) {
+      expect({ ...(err as Error) }).toStrictEqual({
+        name: "ParseError",
+        text: "Unexpected number",
+        kind: "error",
+        location: {
+          file,
+          fileText,
+          line: 4,
+          column: 8,
+          lineText: `\t\t\t"c":[012345]`,
+        },
+        notes: [],
+      });
+    }
+  });
+});
+
+describe("indexLocation", () => {
+  it("should calculate location from one-line input", () => {
+    const fileText = "";
+    expect(indexLocation({ fileText }, 1)).toStrictEqual({
+      fileText,
+      line: 1,
+      column: 0,
+      lineText: "",
+    });
+  });
+
+  it("should calculate location from multi-line input", () => {
+    const file = "package.json",
+      fileText = `\n{\n\t"hello":"world"\n}\n`;
+    expect(indexLocation({ file, fileText }, 11)).toStrictEqual({
+      file,
+      fileText,
+      line: 3,
+      column: 7,
+      lineText: `\t"hello":"world"`,
+    });
+  });
+
+  it("should calculate location when index is out of bounds", () => {
+    const fileText = `\n\n\n\n`;
+    expect(indexLocation({ fileText }, 10)).toStrictEqual({
+      fileText,
+      line: 5,
+      column: 0,
+      lineText: undefined,
+    });
+  });
+});
+
+describe("searchLocation", () => {
+  it("should calculate location from one-line match", () => {
+    const file = "config.toml",
+      fileText = `name = 'coolthing'`;
+    expect(searchLocation({ file, fileText }, "coolthing")).toStrictEqual({
+      file,
+      fileText,
+      line: 1,
+      column: 8,
+      length: 9,
+      lineText: `name = 'coolthing'`,
+    });
+  });
+
+  it("should calculate location from multi-line match", () => {
+    const fileText = `\n{"versions":[\n\t"1.2.3",\n\t"1.2.4",\n\t"1.2.5"\n]}\n`;
+    expect(searchLocation({ fileText }, "1.2.4")).toStrictEqual({
+      fileText,
+      line: 4,
+      column: 2,
+      length: 5,
+      lineText: `\t"1.2.4",`,
+    });
+  });
+
+  it("should calculate location from no match", () => {
+    const fileText = `\n{}\n`;
+    expect(searchLocation({ fileText }, "apple")).toStrictEqual({
+      fileText,
+      line: 3,
+      column: 0,
+      length: undefined,
+      lineText: undefined,
+    });
+  });
+});