wrangler 0.0.0-ece06ea → 0.0.0-ed4f2ef

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,180 @@
+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 { Project, Deployment } from "../pages";
+
+describe("subcommand implicit help ran on incomplete command execution", () => {
+  runInTempDir();
+  const std = mockConsoleMethods();
+  function endEventLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+  }
+
+  it("should should display a list of available subcommands, for pages with no subcommand", 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]
+
+      🚧 'wrangler pages <command>' is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose"
+    `);
+  });
+
+  describe("beta message for subcommands", () => {
+    it("should display for pages:dev", async () => {
+      await expect(
+        runWrangler("pages dev")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Must specify a directory of static assets to serve or a command to run."`
+      );
+
+      expect(std.out).toMatchInlineSnapshot(
+        `"🚧 'wrangler pages <command>' is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose"`
+      );
+    });
+
+    // Note that `wrangler pages functions` does nothing...
+
+    it("should display for pages:functions:build", async () => {
+      await expect(runWrangler("pages functions build")).rejects.toThrowError();
+
+      expect(std.out).toMatchInlineSnapshot(
+        `"🚧 'wrangler pages <command>' is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose"`
+      );
+    });
+  });
+
+  describe("project list", () => {
+    mockAccountId();
+    mockApiToken();
+
+    afterEach(() => {
+      unsetAllMocks();
+    });
+    function mockListRequest(projects: unknown[]) {
+      const requests = { count: 0 };
+      setMockResponse(
+        "/accounts/:accountId/pages/projects",
+        ([_url, accountId], init, query) => {
+          requests.count++;
+          expect(accountId).toEqual("some-account-id");
+          expect(query.get("per_page")).toEqual("10");
+          expect(query.get("page")).toEqual(`${requests.count}`);
+          expect(init).toEqual({});
+          const pageSize = Number(query.get("per_page"));
+          const page = Number(query.get("page"));
+          return projects.slice((page - 1) * pageSize, page * pageSize);
+        }
+      );
+      return requests;
+    }
+
+    it("should make request to list projects", async () => {
+      const projects: Project[] = [
+        {
+          name: "dogs",
+          domains: ["dogs.pages.dev"],
+          source: {
+            type: "github",
+          },
+          latest_deployment: {
+            modified_on: "2021-11-17T14:52:26.133835Z",
+          },
+        },
+        {
+          name: "cats",
+          domains: ["cats.pages.dev", "kitten.pages.dev"],
+          latest_deployment: {
+            modified_on: "2021-11-17T14:52:26.133835Z",
+          },
+        },
+      ];
+
+      const requests = mockListRequest(projects);
+      await runWrangler("pages project list");
+
+      expect(requests.count).toBe(1);
+    });
+
+    it("should make multiple requests for paginated results", async () => {
+      const projects: Project[] = [];
+      for (let i = 0; i < 15; i++) {
+        projects.push({
+          name: "dogs" + i,
+          domains: [i + "dogs.pages.dev"],
+          source: {
+            type: "github",
+          },
+          latest_deployment: {
+            modified_on: "2021-11-17T14:52:26.133835Z",
+          },
+        });
+      }
+      const requests = mockListRequest(projects);
+      await runWrangler("pages project list");
+      expect(requests.count).toEqual(2);
+    });
+  });
+
+  describe("deployment list", () => {
+    mockAccountId();
+    mockApiToken();
+
+    afterEach(() => {
+      unsetAllMocks();
+    });
+    function mockListRequest(deployments: unknown[]) {
+      const requests = { count: 0 };
+      setMockResponse(
+        "/accounts/:accountId/pages/projects/:project/deployments",
+        ([_url, accountId, project]) => {
+          requests.count++;
+          expect(project).toEqual("images");
+          expect(accountId).toEqual("some-account-id");
+          return deployments;
+        }
+      );
+      return requests;
+    }
+
+    it("should make request to list deployments", async () => {
+      const deployments: Deployment[] = [
+        {
+          id: "87bbc8fe-16be-45cd-81e0-63d722e82cdf",
+          url: "https://87bbc8fe.images.pages.dev",
+          environment: "preview",
+          latest_stage: {
+            ended_on: "2021-11-17T14:52:26.133835Z",
+            status: "success",
+          },
+          deployment_trigger: {
+            metadata: {
+              branch: "main",
+              commit_hash: "c7649364c4cb32ad4f65b530b9424e8be5bec9d6",
+            },
+          },
+          project_name: "images",
+        },
+      ];
+
+      const requests = mockListRequest(deployments);
+      await runWrangler("pages deployment list --project=images");
+
+      expect(requests.count).toBe(1);
+    });
+  });
+});

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,
+    });
+  });
+});