wrangler 0.0.0-e2a26a0 → 0.0.0-e322475

package/src/__tests__/logger.test.ts

@@ -0,0 +1,141 @@
+import { logger } from "../logger";
+import { mockConsoleMethods } from "./helpers/mock-console";
+
+describe("logger", () => {
+  const std = mockConsoleMethods();
+
+  it("should add colored markers to error and warning messages", () => {
+    logger.loggerLevel = "debug";
+    logger.debug("This is a debug message");
+    logger.log("This is a log message");
+    logger.warn("This is a warn message");
+    logger.error("This is a error message");
+
+    expect(std.debug).toMatchInlineSnapshot(`"This is a debug message"`);
+    expect(std.out).toMatchInlineSnapshot(`"This is a log message"`);
+    expect(std.warn).toMatchInlineSnapshot(`
+      "▲ [WARNING] This is a warn message
+
+      "
+    `);
+    expect(std.err).toMatchInlineSnapshot(`
+      "X [ERROR] This is a error message
+
+      "
+    `);
+  });
+
+  describe("loggerLevel=debug", () => {
+    it("should render messages that are at or above the log level set in the logger", () => {
+      logger.loggerLevel = "debug";
+      logger.debug("This is a debug message");
+      logger.log("This is a log message");
+      logger.warn("This is a warn message");
+      logger.error("This is a error message");
+
+      expect(std.debug).toMatchInlineSnapshot(`"This is a debug message"`);
+      expect(std.out).toMatchInlineSnapshot(`"This is a log message"`);
+      expect(std.warn).toMatchInlineSnapshot(`
+        "▲ [WARNING] This is a warn message
+
+        "
+      `);
+      expect(std.err).toMatchInlineSnapshot(`
+        "X [ERROR] This is a error message
+
+        "
+      `);
+    });
+  });
+
+  describe("loggerLevel=log", () => {
+    it("should render messages that are at or above the log level set in the logger", () => {
+      logger.loggerLevel = "log";
+      logger.debug("This is a debug message");
+      logger.log("This is a log message");
+      logger.warn("This is a warn message");
+      logger.error("This is a error message");
+
+      expect(std.debug).toMatchInlineSnapshot(`""`);
+      expect(std.out).toMatchInlineSnapshot(`"This is a log message"`);
+      expect(std.warn).toMatchInlineSnapshot(`
+        "▲ [WARNING] This is a warn message
+
+        "
+      `);
+      expect(std.err).toMatchInlineSnapshot(`
+        "X [ERROR] This is a error message
+
+        "
+      `);
+    });
+  });
+
+  describe("loggerLevel=warn", () => {
+    it("should render messages that are at or above the log level set in the logger", () => {
+      logger.loggerLevel = "warn";
+      logger.debug("This is a debug message");
+      logger.log("This is a log message");
+      logger.warn("This is a warn message");
+      logger.error("This is a error message");
+
+      expect(std.debug).toMatchInlineSnapshot(`""`);
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`
+        "▲ [WARNING] This is a warn message
+
+        "
+      `);
+      expect(std.err).toMatchInlineSnapshot(`
+        "X [ERROR] This is a error message
+
+        "
+      `);
+    });
+  });
+
+  describe("loggerLevel=error", () => {
+    it("should render messages that are at or above the log level set in the logger", () => {
+      logger.loggerLevel = "error";
+      logger.debug("This is a debug message");
+      logger.log("This is a log message");
+      logger.warn("This is a warn message");
+      logger.error("This is a error message");
+
+      expect(std.debug).toMatchInlineSnapshot(`""`);
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
+        "X [ERROR] This is a error message
+
+        "
+      `);
+    });
+  });
+
+  describe("loggerLevelFromEnvVar=error", () => {
+    beforeEach(() => {
+      process.env.WRANGLER_LOG = "error";
+    });
+    afterEach(() => {
+      process.env.WRANGLER_LOG = undefined;
+    });
+
+    it("should render messages that are at or above the log level set in the env var", () => {
+      logger.loggerLevel = "error";
+      logger.debug("This is a debug message");
+      logger.log("This is a log message");
+      logger.warn("This is a warn message");
+      logger.error("This is a error message");
+
+      expect(std.debug).toMatchInlineSnapshot(`""`);
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
+        "X [ERROR] This is a error message
+
+        "
+      `);
+    });
+  });
+});

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

@@ -7,100 +7,210 @@ const { getPackageManager, getPackageManagerName } =
   jest.requireActual("../package-manager");
 interface TestCase {
   npm: boolean;
+  pnpm: boolean;
   yarn: boolean;
   npmLockFile: boolean;
   yarnLockFile: boolean;
+  pnpmLockFile: boolean;
   expectedPackageManager: string;
 }
 
 const testCases: TestCase[] = [
-  // npm binary - no yarn binary
+  // npm binary only
   {
     npm: true,
     yarn: false,
+    pnpm: false,
     npmLockFile: false,
     yarnLockFile: false,
+    pnpmLockFile: false,
     expectedPackageManager: "npm",
   },
   {
     npm: true,
     yarn: false,
+    pnpm: false,
     npmLockFile: true,
     yarnLockFile: false,
+    pnpmLockFile: false,
     expectedPackageManager: "npm",
   },
   {
     npm: true,
     yarn: false,
+    pnpm: false,
     npmLockFile: false,
     yarnLockFile: true,
+    pnpmLockFile: false,
     expectedPackageManager: "npm",
   },
   {
     npm: true,
     yarn: false,
+    pnpm: false,
     npmLockFile: true,
     yarnLockFile: true,
+    pnpmLockFile: false,
     expectedPackageManager: "npm",
   },
 
-  // yarn binary - no npm binary
+  // yarn binary only
   {
     npm: false,
     yarn: true,
+    pnpm: false,
     npmLockFile: false,
     yarnLockFile: false,
+    pnpmLockFile: false,
     expectedPackageManager: "yarn",
   },
   {
     npm: false,
     yarn: true,
+    pnpm: false,
     npmLockFile: true,
     yarnLockFile: false,
+    pnpmLockFile: false,
     expectedPackageManager: "yarn",
   },
   {
     npm: false,
     yarn: true,
+    pnpm: false,
     npmLockFile: false,
     yarnLockFile: true,
+    pnpmLockFile: false,
     expectedPackageManager: "yarn",
   },
   {
     npm: false,
     yarn: true,
+    pnpm: false,
     npmLockFile: true,
     yarnLockFile: true,
+    pnpmLockFile: false,
     expectedPackageManager: "yarn",
   },
 
+  // pnpm binary only
+  {
+    npm: false,
+    yarn: false,
+    pnpm: true,
+    npmLockFile: false,
+    yarnLockFile: false,
+    pnpmLockFile: true,
+    expectedPackageManager: "pnpm",
+  },
+  {
+    npm: false,
+    yarn: false,
+    pnpm: true,
+    npmLockFile: true,
+    yarnLockFile: false,
+    pnpmLockFile: false,
+    expectedPackageManager: "pnpm",
+  },
+  {
+    npm: false,
+    yarn: false,
+    pnpm: true,
+    npmLockFile: false,
+    yarnLockFile: true,
+    pnpmLockFile: false,
+    expectedPackageManager: "pnpm",
+  },
+  {
+    npm: false,
+    yarn: false,
+    pnpm: true,
+    npmLockFile: true,
+    yarnLockFile: true,
+    pnpmLockFile: true,
+    expectedPackageManager: "pnpm",
+  },
+
   // npm and yarn binaries
   {
     npm: true,
     yarn: true,
+    pnpm: false,
+    npmLockFile: false,
+    yarnLockFile: false,
+    pnpmLockFile: false,
+    expectedPackageManager: "npm",
+  },
+  {
+    npm: true,
+    yarn: true,
+    pnpm: false,
+    npmLockFile: true,
+    yarnLockFile: false,
+    pnpmLockFile: false,
+    expectedPackageManager: "npm",
+  },
+  {
+    npm: true,
+    yarn: true,
+    pnpm: false,
+    npmLockFile: false,
+    yarnLockFile: true,
+    pnpmLockFile: false,
+    expectedPackageManager: "yarn",
+  },
+  {
+    npm: true,
+    yarn: true,
+    pnpm: false,
+    npmLockFile: true,
+    yarnLockFile: true,
+    pnpmLockFile: false,
+    expectedPackageManager: "npm",
+  },
+  // npm, yarn and pnpm binaries
+  {
+    npm: true,
+    yarn: true,
+    pnpm: true,
     npmLockFile: false,
     yarnLockFile: false,
+    pnpmLockFile: false,
     expectedPackageManager: "npm",
   },
   {
     npm: true,
     yarn: true,
+    pnpm: true,
     npmLockFile: true,
     yarnLockFile: false,
+    pnpmLockFile: false,
     expectedPackageManager: "npm",
   },
   {
     npm: true,
     yarn: true,
+    pnpm: true,
     npmLockFile: false,
     yarnLockFile: true,
+    pnpmLockFile: false,
     expectedPackageManager: "yarn",
   },
   {
     npm: true,
     yarn: true,
+    pnpm: true,
+    npmLockFile: false,
+    yarnLockFile: false,
+    pnpmLockFile: true,
+    expectedPackageManager: "pnpm",
+  },
+  {
+    npm: true,
+    yarn: true,
+    pnpm: true,
     npmLockFile: true,
     yarnLockFile: true,
+    pnpmLockFile: true,
     expectedPackageManager: "npm",
   },
 ];
@@ -112,12 +222,13 @@ describe("getPackageManager()", () => {
   describe("no supported package manager", () => {
     mockYarn(false);
     mockNpm(false);
+    mockPnpm(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."`
+        `"Unable to find a package manager. Supported managers are: npm, yarn, and pnpm."`
       );
     });
   });
@@ -125,16 +236,26 @@ describe("getPackageManager()", () => {
   for (const {
     npm,
     yarn,
+    pnpm,
     npmLockFile,
     yarnLockFile,
+    pnpmLockFile,
     expectedPackageManager,
   } of testCases) {
     describe(
-      getTestCaseDescription(npm, yarn, npmLockFile, yarnLockFile),
+      getTestCaseDescription(
+        npm,
+        yarn,
+        pnpm,
+        npmLockFile,
+        yarnLockFile,
+        pnpmLockFile
+      ),
       () => {
         mockYarn(yarn);
         mockNpm(npm);
-        mockLockFiles(npmLockFile, yarnLockFile);
+        mockPnpm(pnpm);
+        mockLockFiles(npmLockFile, yarnLockFile, pnpmLockFile);
 
         it(`should return the ${expectedPackageManager} package manager`, async () => {
           const actualPackageManager = await getPackageManager(process.cwd());
@@ -151,7 +272,7 @@ describe("getPackageManager()", () => {
  * Create a fake yarn binary
  */
 function mockYarn(succeed: boolean): void {
-  let unMock;
+  let unMock: () => void;
   beforeEach(async () => {
     unMock = await mockBinary("yarn", `process.exit(${succeed ? 0 : 1})`);
   });
@@ -162,17 +283,32 @@ function mockYarn(succeed: boolean): void {
  * Create a fake npm binary
  */
 function mockNpm(succeed: boolean): void {
-  let unMock;
+  let unMock: () => void;
   beforeEach(async () => {
     unMock = await mockBinary("npm", `process.exit(${succeed ? 0 : 1})`);
   });
   afterEach(() => unMock());
 }
 
+/**
+ * Create a fake pnpm binary
+ */
+function mockPnpm(succeed: boolean): void {
+  let unMock: () => void;
+  beforeEach(async () => {
+    unMock = await mockBinary("pnpm", `process.exit(${succeed ? 0 : 1})`);
+  });
+  afterEach(() => unMock());
+}
+
 /**
  * Create a fake lock files.
  */
-function mockLockFiles(npmLockFile: boolean, yarnLockFile: boolean) {
+function mockLockFiles(
+  npmLockFile: boolean,
+  yarnLockFile: boolean,
+  pnpmLockFile: boolean
+) {
   beforeEach(() => {
     if (npmLockFile) {
       writeFileSync("package-lock.json", "");
@@ -180,14 +316,19 @@ function mockLockFiles(npmLockFile: boolean, yarnLockFile: boolean) {
     if (yarnLockFile) {
       writeFileSync("yarn.lock", "");
     }
+    if (pnpmLockFile) {
+      writeFileSync("pnpm-lock.yaml", "");
+    }
   });
 }
 
 function getTestCaseDescription(
   npm: boolean,
   yarn: boolean,
+  pnpm: boolean,
   npmLockFile: boolean,
-  yarnLockFile: boolean
+  yarnLockFile: boolean,
+  pnpmLockFile: boolean
 ): string {
   const criteria: string[] = [];
   if (npm) {
@@ -202,5 +343,11 @@ function getTestCaseDescription(
   if (yarnLockFile) {
     criteria.push("yarn.lock");
   }
+  if (pnpm) {
+    criteria.push("pnpm");
+  }
+  if (pnpmLockFile) {
+    criteria.push("pnpm-lock.yaml");
+  }
   return "using " + criteria.join("; ");
 }