@monorepolint/rules 0.5.0-alpha.12 → 0.5.0-alpha.125

package/src/__tests__/nestedWorkspaces.spec.ts

@@ -0,0 +1,153 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { WorkspaceContextImpl } from "@monorepolint/core";
+import { SimpleHost } from "@monorepolint/utils";
+import { writeFileSync } from "fs";
+import * as path from "path";
+import * as tmp from "tmp";
+import { nestedWorkspaces } from "../nestedWorkspaces.js";
+import { makeDirectoryRecursively } from "../util/makeDirectory.js";
+import { jsonToString } from "./utils.js";
+import { describe, expect, it, beforeEach, afterEach, jest } from "@jest/globals";
+
+const EMPTY_PACKAGE = jsonToString({});
+
+const PACKAGE_ROOT_WITH_PACKAGES_STAR = jsonToString({
+  workspaces: {
+    packages: ["packages/*"],
+  },
+});
+
+const PACKAGE_ROOT_WITH_TWO_LEVEL = jsonToString({
+  workspaces: {
+    packages: ["packages/*", "packages/deep/*"],
+  },
+});
+
+const PACKAGE_ROOT_WITH_THREE_LEVEL = jsonToString({
+  workspaces: {
+    packages: ["packages/*", "packages/deep/*", "packages/very/deep/*"],
+  },
+});
+
+describe("nestedWorkspaces", () => {
+  tmp.setGracefulCleanup();
+
+  let cleanupJobs: Array<() => void> = [];
+  let cwd: string | undefined;
+
+  beforeEach(() => {
+    const dir = tmp.dirSync({ unsafeCleanup: true });
+    cleanupJobs.push(() => dir.removeCallback());
+    cwd = dir.name;
+
+    const spy = jest.spyOn(process, "cwd");
+    spy.mockReturnValue(cwd);
+  });
+
+  afterEach(() => {
+    for (const cleanupJob of cleanupJobs) {
+      cleanupJob();
+    }
+    cleanupJobs = [];
+  });
+
+  function makeWorkspace() {
+    const host = new SimpleHost();
+    const workspaceContext = new WorkspaceContextImpl(
+      cwd!,
+      {
+        rules: [],
+        fix: false,
+        verbose: false,
+        silent: true,
+      },
+      host
+    );
+
+    async function checkAndSpy() {
+      const addErrorSpy = jest.spyOn(workspaceContext, "addError");
+
+      await nestedWorkspaces({}).check(workspaceContext);
+      return { addErrorSpy };
+    }
+
+    function addFile(filePath: string, content: string) {
+      const dirPath = path.resolve(cwd!, path.dirname(filePath));
+      const resolvedFilePath = path.resolve(cwd!, filePath);
+
+      makeDirectoryRecursively(dirPath);
+      writeFileSync(resolvedFilePath, content);
+      return resolvedFilePath;
+    }
+
+    return { addFile, workspaceContext, checkAndSpy };
+  }
+
+  it("checks correctly when no packages", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    addFile("./package.json", EMPTY_PACKAGE);
+
+    expect((await checkAndSpy()).addErrorSpy).toHaveBeenCalledTimes(0);
+  });
+
+  it("checks correctly when one level packages", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    addFile("./package.json", PACKAGE_ROOT_WITH_PACKAGES_STAR);
+    addFile("./packages/star/package.json", EMPTY_PACKAGE);
+
+    expect((await checkAndSpy()).addErrorSpy).toHaveBeenCalledTimes(0);
+  });
+
+  it("checks fail when one level packages with no workspaces field", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    const packageJsonPath = addFile("./package.json", EMPTY_PACKAGE);
+    addFile("./packages/star/package.json", EMPTY_PACKAGE);
+
+    const spy = (await checkAndSpy()).addErrorSpy;
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith({
+      file: packageJsonPath,
+      message: 'The "workspace" field is missing, even though there are workspaces in the repository.',
+    });
+  });
+
+  it("checks correctly when two level packages with two level workspaces field", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    addFile("./package.json", PACKAGE_ROOT_WITH_TWO_LEVEL);
+    addFile("./packages/star/package.json", EMPTY_PACKAGE);
+    addFile("./packages/deep/star/package.json", EMPTY_PACKAGE);
+
+    expect((await checkAndSpy()).addErrorSpy).toHaveBeenCalledTimes(0);
+  });
+
+  it("checks fail when two level packages with one level workspaces field", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    const packageJsonPath = addFile("./package.json", PACKAGE_ROOT_WITH_PACKAGES_STAR);
+    addFile("./packages/star/package.json", EMPTY_PACKAGE);
+    addFile("./packages/deep/star/package.json", EMPTY_PACKAGE);
+
+    const spy = (await checkAndSpy()).addErrorSpy;
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith({
+      file: packageJsonPath,
+      message:
+        'The "workspace" field is missing one or more values: packages/deep/star. ' +
+        'You may be able to use a glob to avoid listing each workspace individually, e.g. "packages/nested-workspace/*".',
+    });
+  });
+
+  it("checks correctly when three level packages with three level workspaces field", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    addFile("./package.json", PACKAGE_ROOT_WITH_THREE_LEVEL);
+    addFile("./packages/star/package.json", EMPTY_PACKAGE);
+    addFile("./packages/deep/star/package.json", EMPTY_PACKAGE);
+    addFile("./packages/very/deep/star/package.json", EMPTY_PACKAGE);
+
+    expect((await checkAndSpy()).addErrorSpy).toHaveBeenCalledTimes(0);
+  });
+});

package/src/__tests__/packageEntry.spec.ts

@@ -6,13 +6,11 @@
  */
 
 // tslint:disable:no-console
-import { createMockFiles } from "./utils";
 
-// done first since this also mocks 'fs'
-const mockFiles: Map<string, string> = createMockFiles();
-
-import { Failure, PackageContext } from "@monorepolint/core";
-import { packageEntry } from "../packageEntry";
+import { Context, Failure } from "@monorepolint/config";
+import { createExpectedEntryErrorMessage, createStandardizedEntryErrorMessage, packageEntry } from "../packageEntry.js";
+import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils.js";
+import { describe, expect, it, beforeEach, afterEach, jest } from "@jest/globals";
 
 const PACKAGE_MISSING_ENTRY =
   JSON.stringify(
@@ -55,79 +53,159 @@ const PACKAGE_REPOSITORY =
     2
   ) + "\n";
 
-describe("expectPackageEntries", () => {
-  afterEach(() => {
-    mockFiles.clear();
-  });
-
+describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
   describe("fix: true", () => {
-    const context = new PackageContext(".", {
-      rules: [],
-      fix: true,
-      verbose: false,
-      silent: true,
+    let workspace: TestingWorkspace;
+    let spy: AddErrorSpy;
+    let context: Context;
+
+    beforeEach(async () => {
+      workspace = await createTestingWorkspace({
+        fixFlag: true,
+        host: hostFactory.make(),
+      });
+      context = workspace.context; // minimizing delta
+
+      spy = jest.spyOn(workspace.context, "addError");
     });
-    const spy = jest.spyOn(context, "addError");
 
     afterEach(() => {
       spy.mockClear();
     });
 
     it("fixes missing entries", () => {
-      mockFiles.set("package.json", PACKAGE_MISSING_ENTRY);
+      workspace.writeFile("package.json", PACKAGE_MISSING_ENTRY);
 
-      packageEntry.check(context, {
-        entries: {
-          license: "UNLICENSED",
+      packageEntry({
+        options: {
+          entries: {
+            license: "UNLICENSED",
+          },
+          entriesExist: undefined,
         },
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
       const failure: Failure = spy.mock.calls[0][0];
-      expect(failure.file).toBe("package.json");
-      expect(failure.fixer).not.toBeUndefined();
-      expect(failure.message).toBe("Expected standardized entry for 'license'");
-
-      expect(mockFiles.get("package.json")).toEqual(PACKAGE_LICENSE);
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: createStandardizedEntryErrorMessage("license"),
+        })
+      );
+
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_LICENSE);
     });
 
     it("fixes missing nested entries", () => {
-      mockFiles.set("package.json", PACKAGE_MISSING_ENTRY);
-
-      packageEntry.check(context, {
-        entries: {
-          repository: {
-            type: "git",
-            url: "https://github.com:foo/foo",
+      workspace.writeFile("package.json", PACKAGE_MISSING_ENTRY);
+
+      packageEntry({
+        options: {
+          entries: {
+            repository: {
+              type: "git",
+              url: "https://github.com:foo/foo",
+            },
           },
+          entriesExist: undefined,
         },
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
       const failure: Failure = spy.mock.calls[0][0];
-      expect(failure.file).toBe("package.json");
-      expect(failure.fixer).not.toBeUndefined();
-      expect(failure.message).toBe("Expected standardized entry for 'repository'");
-
-      expect(mockFiles.get("package.json")).toEqual(PACKAGE_REPOSITORY);
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: createStandardizedEntryErrorMessage("repository"),
+        })
+      );
+
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_REPOSITORY);
     });
 
     it("doesn't error for nested entries that are defined", () => {
-      mockFiles.set("package.json", PACKAGE_REPOSITORY);
-
-      packageEntry.check(context, {
-        entries: {
-          repository: {
-            type: "git",
-            url: "https://github.com:foo/foo",
+      workspace.writeFile("package.json", PACKAGE_REPOSITORY);
+
+      packageEntry({
+        options: {
+          entries: {
+            repository: {
+              type: "git",
+              url: "https://github.com:foo/foo",
+            },
           },
+          entriesExist: undefined,
         },
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(0);
-      expect(mockFiles.get("package.json")).toEqual(PACKAGE_REPOSITORY);
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_REPOSITORY);
+    });
+
+    it("errors for keys that are missing", () => {
+      workspace.writeFile("package.json", PACKAGE_REPOSITORY);
+
+      packageEntry({
+        options: {
+          entries: undefined,
+          entriesExist: ["bugs"],
+        },
+      }).check(context);
+
+      expect(spy).toHaveBeenCalledTimes(1);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: false,
+          message: createExpectedEntryErrorMessage("bugs"),
+        })
+      );
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_REPOSITORY);
+    });
+
+    it("handles both entries and entriesExist", () => {
+      workspace.writeFile("package.json", PACKAGE_MISSING_ENTRY);
+
+      packageEntry({
+        options: {
+          entries: {
+            repository: {
+              type: "git",
+              url: "https://github.com:foo/foo",
+            },
+          },
+          entriesExist: ["bugs"],
+        },
+      }).check(context);
+
+      expect(spy).toHaveBeenCalledTimes(2);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: createStandardizedEntryErrorMessage("repository"),
+        })
+      );
+
+      const failure2: Failure = spy.mock.calls[1][0];
+      expect(failure2).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: false,
+          message: createExpectedEntryErrorMessage("bugs"),
+        })
+      );
+
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_REPOSITORY);
     });
   });
 });

package/src/__tests__/packageOrder.spec.ts

@@ -6,13 +6,10 @@
  */
 
 // tslint:disable:no-console
-import { createMockFiles } from "./utils";
-
-// done first since this also mocks 'fs'
-const mockFiles: Map<string, string> = createMockFiles();
-
-import { Context, Failure, PackageContext } from "@monorepolint/core";
-import { packageOrder } from "../packageOrder";
+import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils.js";
+import { Context, Failure } from "@monorepolint/config";
+import { packageOrder } from "../packageOrder.js";
+import { describe, expect, it, beforeEach, jest } from "@jest/globals";
 
 const PACKAGE_UNORDERED =
   JSON.stringify(
@@ -85,85 +82,103 @@ const PACKAGE_ORDERED_UNKOWN_KEYS =
     2
   ) + "\n";
 
-describe("expectPackageOrder", () => {
-  afterEach(() => {
-    mockFiles.clear();
-  });
-
+describe.each(HOST_FACTORIES)("expectPackageOrder ($name)", (hostFactory) => {
   describe("fix: true", () => {
-    const context = new PackageContext(".", {
-      rules: [],
-      fix: true,
-      verbose: false,
-      silent: true,
-    });
-    const spy = jest.spyOn(context, "addError");
+    let workspace: TestingWorkspace;
+    let spy: AddErrorSpy;
+    let context: Context;
+
+    beforeEach(async () => {
+      workspace = await createTestingWorkspace({
+        fixFlag: true,
+        host: hostFactory.make(),
+      });
+      context = workspace.context; // minimizing delta
 
-    afterEach(() => {
-      spy.mockClear();
+      spy = jest.spyOn(workspace.context, "addError");
     });
 
     it("fixes order for expected keys", () => {
-      mockFiles.set("package.json", PACKAGE_UNORDERED);
+      workspace.writeFile("package.json", PACKAGE_UNORDERED);
 
-      packageOrder.check(context, {
-        order: orderArray,
-      });
+      packageOrder({
+        options: {
+          order: orderArray,
+        },
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
       const failure: Failure = spy.mock.calls[0][0];
-      expect(failure.file).toBe("package.json");
-      expect(failure.fixer).not.toBeUndefined();
-      expect(failure.message).toBe("Incorrect order of fields in package.json");
-
-      expect(mockFiles.get("package.json")).toEqual(PACKAGE_ORDERED);
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: "Incorrect order of fields in package.json",
+        })
+      );
+
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_ORDERED);
     });
 
     it("fixes order for unexpected keys", () => {
-      mockFiles.set("package.json", PACKAGE_UNORDERED_UNKOWN_KEYS);
+      workspace.writeFile("package.json", PACKAGE_UNORDERED_UNKOWN_KEYS);
 
-      packageOrder.check(context, {
-        order: orderArray,
-      });
+      packageOrder({
+        options: {
+          order: orderArray,
+        },
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
       const failure: Failure = spy.mock.calls[0][0];
-      expect(failure.file).toBe("package.json");
-      expect(failure.fixer).not.toBeUndefined();
-      expect(failure.message).toBe("Incorrect order of fields in package.json");
-
-      expect(mockFiles.get("package.json")).toEqual(PACKAGE_ORDERED_UNKOWN_KEYS);
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: "Incorrect order of fields in package.json",
+        })
+      );
+
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_ORDERED_UNKOWN_KEYS);
     });
 
     it("fixes order using function", () => {
-      mockFiles.set("package.json", PACKAGE_UNORDERED);
+      workspace.writeFile("package.json", PACKAGE_UNORDERED);
 
-      packageOrder.check(context, {
-        order: orderFunction,
-      });
+      packageOrder({
+        options: {
+          order: orderFunction,
+        },
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
       const failure: Failure = spy.mock.calls[0][0];
-      expect(failure.file).toBe("package.json");
-      expect(failure.fixer).not.toBeUndefined();
-      expect(failure.message).toBe("Incorrect order of fields in package.json");
-
-      expect(mockFiles.get("package.json")).toEqual(PACKAGE_ORDERED_BY_LENGTH);
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: "Incorrect order of fields in package.json",
+        })
+      );
+
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_ORDERED_BY_LENGTH);
     });
 
     it("does nothing if already order", () => {
-      mockFiles.set("package.json", PACKAGE_ORDERED_UNKOWN_KEYS);
+      workspace.writeFile("package.json", PACKAGE_ORDERED_UNKOWN_KEYS);
 
-      packageOrder.check(context, {
-        order: orderArray,
-      });
+      packageOrder({
+        options: {
+          order: orderArray,
+        },
+      }).check(context);
 
       expect(spy).not.toHaveBeenCalled();
 
-      expect(mockFiles.get("package.json")).toEqual(PACKAGE_ORDERED_UNKOWN_KEYS);
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_ORDERED_UNKOWN_KEYS);
     });
   });
 });