@monorepolint/rules 0.5.0-alpha.9 → 0.5.0-alpha.95

package/src/__tests__/bannedDependencies.spec.ts

@@ -0,0 +1,191 @@
+/*!
+ * Copyright 2020 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { WorkspaceContext } from "@monorepolint/core";
+import { SimpleHost } from "@monorepolint/utils";
+import { writeFileSync } from "fs";
+import * as path from "path";
+import * as tmp from "tmp";
+import { bannedDependencies, Options } from "../bannedDependencies";
+import { makeDirectoryRecursively } from "../util/makeDirectory";
+import { jsonToString } from "./utils";
+
+const EMPTY_PACKAGE = jsonToString({});
+
+describe("bannedDependencies", () => {
+  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 workspaceContext = new WorkspaceContext(
+      cwd!,
+      {
+        rules: [],
+        fix: false,
+        verbose: false,
+        silent: true,
+      },
+      new SimpleHost()
+    );
+
+    function checkAndSpy(options: Options) {
+      const addErrorSpy = jest.spyOn(workspaceContext, "addError");
+      bannedDependencies.check(workspaceContext, {
+        ...options,
+      });
+      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("Flags banned dependencies correctly", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    const rootPackageJson = jsonToString({
+      dependencies: {
+        aaa: "0.0.1",
+        ccc: "0.0.1",
+      },
+    });
+    addFile("./package.json", rootPackageJson);
+
+    const { addErrorSpy: addErrorSpy1 } = checkAndSpy({ bannedDependencies: ["ccc"] });
+    expect(addErrorSpy1).toHaveBeenCalledTimes(1);
+    addErrorSpy1.mockReset();
+
+    const { addErrorSpy: addErrorSpy2 } = checkAndSpy({ bannedDependencies: ["ddd"] });
+    expect(addErrorSpy2).toHaveBeenCalledTimes(0);
+    addErrorSpy2.mockReset();
+
+    const { addErrorSpy: addErrorSpy3 } = checkAndSpy({ bannedDependencies: ["ccc", "ddd"] });
+    expect(addErrorSpy3).toHaveBeenCalledTimes(1);
+    addErrorSpy3.mockReset();
+  });
+
+  it("Flags banned dependencies correctly w legacy globs", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    const rootPackageJson = jsonToString({
+      dependencies: {
+        aaa: "0.0.1",
+        ccc: "0.0.1",
+      },
+    });
+    addFile("./package.json", rootPackageJson);
+
+    const { addErrorSpy: addErrorSpy1 } = checkAndSpy({ bannedDependencies: ["c*c"] });
+    expect(addErrorSpy1).toHaveBeenCalledTimes(1);
+    addErrorSpy1.mockReset();
+
+    const { addErrorSpy: addErrorSpy2 } = checkAndSpy({ bannedDependencies: ["d*d"] });
+    expect(addErrorSpy2).toHaveBeenCalledTimes(0);
+    addErrorSpy2.mockReset();
+
+    const { addErrorSpy: addErrorSpy3 } = checkAndSpy({ bannedDependencies: ["c*c", "d*d"] });
+    expect(addErrorSpy3).toHaveBeenCalledTimes(1);
+    addErrorSpy3.mockReset();
+  });
+
+  it("Flags banned dependencies correctly w new globs", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    const rootPackageJson = jsonToString({
+      dependencies: {
+        aaa: "0.0.1",
+        ccc: "0.0.1",
+      },
+    });
+    addFile("./package.json", rootPackageJson);
+
+    const { addErrorSpy: addErrorSpy1 } = checkAndSpy({ bannedDependencies: { glob: ["c*c"] } });
+    expect(addErrorSpy1).toHaveBeenCalledTimes(1);
+    addErrorSpy1.mockReset();
+
+    const { addErrorSpy: addErrorSpy2 } = checkAndSpy({ bannedDependencies: { glob: ["d*d"] } });
+    expect(addErrorSpy2).toHaveBeenCalledTimes(0);
+    addErrorSpy2.mockReset();
+
+    const { addErrorSpy: addErrorSpy3 } = checkAndSpy({ bannedDependencies: { glob: ["c*c", "d*d"] } });
+    expect(addErrorSpy3).toHaveBeenCalledTimes(1);
+    addErrorSpy3.mockReset();
+  });
+
+  it("Flags banned dependencies correctly w exact", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    const rootPackageJson = jsonToString({
+      dependencies: {
+        aaa: "0.0.1",
+        ccc: "0.0.1",
+      },
+    });
+    addFile("./package.json", rootPackageJson);
+
+    const { addErrorSpy: addErrorSpy1 } = checkAndSpy({ bannedDependencies: { exact: ["ccc"] } });
+    expect(addErrorSpy1).toHaveBeenCalledTimes(1);
+    addErrorSpy1.mockReset();
+
+    const { addErrorSpy: addErrorSpy2 } = checkAndSpy({ bannedDependencies: { exact: ["ddd"] } });
+    expect(addErrorSpy2).toHaveBeenCalledTimes(0);
+    addErrorSpy2.mockReset();
+
+    const { addErrorSpy: addErrorSpy3 } = checkAndSpy({ bannedDependencies: { exact: ["ccc", "ddd"] } });
+    expect(addErrorSpy3).toHaveBeenCalledTimes(1);
+    addErrorSpy3.mockReset();
+  });
+
+  it("Flags banned transitives correctly", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    const rootPackageJson = jsonToString({
+      dependencies: {
+        aaa: "0.0.1",
+      },
+    });
+    addFile("./package.json", rootPackageJson);
+
+    const aaaPackageJson = jsonToString({
+      dependencies: {
+        bbb: "0.0.1",
+        ccc: "0.0.1",
+      },
+    });
+    addFile("./node_modules/aaa/package.json", aaaPackageJson);
+    const bbbPackageJson = jsonToString({
+      dependencies: {
+        ddd: "0.0.1",
+      },
+    });
+    addFile("./node_modules/aaa/node_modules/bbb/package.json", bbbPackageJson);
+    addFile("./node_modules/aaa/node_modules/bbb/node_modules/ddd/package.json", EMPTY_PACKAGE);
+    addFile("./node_modules/aaa/node_modules/ccc/package.json", EMPTY_PACKAGE);
+
+    expect(checkAndSpy({ bannedTransitiveDependencies: ["ccc", "ddd"] }).addErrorSpy).toHaveBeenCalledTimes(2);
+  });
+});

package/src/__tests__/consistentDependencies.spec.ts

@@ -5,14 +5,13 @@
  *
  */
 import { WorkspaceContext } from "@monorepolint/core";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { SimpleHost } from "@monorepolint/utils";
+import { readFileSync, writeFileSync } from "fs";
 import * as path from "path";
 import * as tmp from "tmp";
-import { consistentDependencies } from "../consistentDependencies";
-
-function jsonToString(obj: {}) {
-  return JSON.stringify(obj, undefined, 2) + "\n";
-}
+import { consistentDependencies, Options } from "../consistentDependencies";
+import { makeDirectoryRecursively } from "../util/makeDirectory";
+import { jsonToString } from "./utils";
 
 const PACKAGE_ROOT = jsonToString({
   workspaces: {
@@ -29,6 +28,12 @@ const PACKAGE_CHILD_WITH_STAR = jsonToString({
   },
 });
 
+const PACKAGE_CHILD_WITH_LATEST = jsonToString({
+  dependencies: {
+    foo: "latest",
+  },
+});
+
 const PACKAGE_CHILD_WITH_RIGHT_VERSION = jsonToString({
   dependencies: {
     foo: "5",
@@ -54,19 +59,24 @@ describe("consistentDependencies", () => {
   });
 
   function makeWorkspace({ fix }: { fix: boolean }) {
-    const dir: tmp.DirResult = tmp.dirSync();
+    const dir: tmp.DirResult = tmp.dirSync({ unsafeCleanup: true });
     cleanupJobs.push(() => dir.removeCallback());
 
-    const workspaceContext = new WorkspaceContext(dir.name, {
-      rules: [],
-      fix,
-      verbose: false,
-    });
-
-    function checkAndSpy(q: string) {
+    const workspaceContext = new WorkspaceContext(
+      dir.name,
+      {
+        rules: [],
+        fix,
+        verbose: false,
+        silent: true,
+      },
+      new SimpleHost()
+    );
+
+    function checkAndSpy(q: string, opts?: Options) {
       const context = workspaceContext.createChildContext(path.resolve(dir.name, q));
       const addErrorSpy = jest.spyOn(context, "addError");
-      consistentDependencies.check(context, undefined);
+      consistentDependencies.check(context, opts);
       return { context, addErrorSpy };
     }
 
@@ -74,17 +84,7 @@ describe("consistentDependencies", () => {
       const dirPath = path.resolve(dir.name, path.dirname(filePath));
       const resolvedFilePath = path.resolve(dir.name, filePath);
 
-      // node < 10 doesn't support mkdirSync w/ recursive: true
-      // so we manually do it instead
-      const dirSegments = dirPath.split(path.sep);
-      for (let i = 2; i <= dirSegments.length; i++) {
-        // we skip the empty segment
-        const curDirPath = dirSegments.slice(0, i).join(path.sep);
-        if (!existsSync(curDirPath)) {
-          mkdirSync(curDirPath);
-        }
-      }
-
+      makeDirectoryRecursively(dirPath);
       writeFileSync(resolvedFilePath, content);
     }
 
@@ -99,6 +99,7 @@ describe("consistentDependencies", () => {
     const { addFile, workspaceContext, checkAndSpy } = makeWorkspace({ fix: false });
     addFile("./package.json", PACKAGE_ROOT);
     addFile("./packages/star/package.json", PACKAGE_CHILD_WITH_STAR);
+    addFile("./packages/latest/package.json", PACKAGE_CHILD_WITH_LATEST);
     addFile("./packages/right/package.json", PACKAGE_CHILD_WITH_RIGHT_VERSION);
     addFile("./packages/wrong/package.json", PACKAGE_CHILD_WITH_WRONG_VERSION);
 
@@ -107,6 +108,9 @@ describe("consistentDependencies", () => {
     const star = checkAndSpy("./packages/star");
     expect(star.addErrorSpy).toHaveBeenCalledTimes(0);
 
+    const latest = checkAndSpy("./packages/latest");
+    expect(latest.addErrorSpy).toHaveBeenCalledTimes(0);
+
     const right = checkAndSpy("./packages/right");
     expect(right.addErrorSpy).toHaveBeenCalledTimes(0);
 
@@ -125,4 +129,13 @@ describe("consistentDependencies", () => {
     const contents = readFile("./packages/wrong/package.json");
     expect(contents).toEqual(PACKAGE_CHILD_WITH_RIGHT_VERSION);
   });
+
+  it("ignores ignored dependencies", () => {
+    const { addFile, checkAndSpy } = makeWorkspace({ fix: false });
+    addFile("./package.json", PACKAGE_ROOT);
+    addFile("./packages/wrong/package.json", PACKAGE_CHILD_WITH_WRONG_VERSION);
+
+    const ignored = checkAndSpy("./packages/wrong", { ignoredDependencies: ["foo"] });
+    expect(ignored.addErrorSpy).toHaveBeenCalledTimes(0);
+  });
 });

package/src/__tests__/consistentVersions.spec.ts

@@ -0,0 +1,223 @@
+/*!
+ * Copyright 2020 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { WorkspaceContext } from "@monorepolint/core";
+import { Host, PackageJson, SimpleHost } from "@monorepolint/utils";
+import * as path from "path";
+import * as tmp from "tmp";
+import { consistentVersions, Options } from "../consistentVersions";
+import { makeDirectoryRecursively } from "../util/makeDirectory";
+
+describe("consistentVersions", () => {
+  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(fix = false) {
+    const host: Host = new SimpleHost();
+    const workspaceContext = new WorkspaceContext(
+      cwd!,
+      {
+        rules: [],
+        fix,
+        verbose: false,
+        silent: true,
+      },
+      host
+    );
+    const addErrorSpy = jest.spyOn(workspaceContext, "addError");
+
+    function check(options: Options = { matchDependencyVersions: {} }) {
+      consistentVersions.check(workspaceContext, options);
+    }
+
+    return { addErrorSpy, check, host };
+  }
+
+  function addPackageJson(host: Host, filePath: string, packageJson: PackageJson) {
+    const dirPath = path.resolve(cwd!, path.dirname(filePath));
+    const resolvedFilePath = path.resolve(cwd!, filePath);
+
+    makeDirectoryRecursively(dirPath);
+    host.writeJson(resolvedFilePath, packageJson);
+    return (): PackageJson => {
+      return host.readJson(resolvedFilePath);
+    };
+  }
+
+  describe("standard tests", () => {
+    let testPackageJson: PackageJson;
+
+    beforeEach(() => {
+      testPackageJson = {
+        name: "test",
+        dependencies: {
+          greatLib: "^15",
+          both: "1",
+        },
+        peerDependencies: {
+          whatever: "15",
+        },
+        devDependencies: {
+          else: "27.2.1",
+          both: "1",
+        },
+      };
+    });
+
+    it("Does nothing when arguments are empty", async () => {
+      const { addErrorSpy, check, host } = makeWorkspace();
+      addPackageJson(host, "./package.json", testPackageJson);
+
+      check();
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({ matchDependencyVersions: {} });
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("Fixes packages that have an incorrect dependency version", async () => {
+      const { addErrorSpy, check, host } = makeWorkspace(true);
+      const readTestPackageJson = addPackageJson(host, "./package.json", testPackageJson);
+
+      const requiredGreatLibVersion = "1.2.3";
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({
+        matchDependencyVersions: { both: testPackageJson.dependencies!.both, greatLib: requiredGreatLibVersion },
+      });
+      expect(addErrorSpy).toHaveBeenCalledTimes(1);
+      expect(readTestPackageJson().dependencies!.greatLib).toEqual(requiredGreatLibVersion);
+    });
+
+    it("Ignores packages that have a correct dependency version", async () => {
+      const { addErrorSpy, check, host } = makeWorkspace();
+      addPackageJson(host, "./package.json", testPackageJson);
+
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({
+        matchDependencyVersions: {
+          both: testPackageJson.dependencies!.both,
+          greatLib: testPackageJson.dependencies!.greatLib,
+        },
+      });
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("Fixes packages that have an incorrect devDependency version", async () => {
+      const { addErrorSpy, check, host } = makeWorkspace(true);
+      const readTestPackageJson = addPackageJson(host, "./package.json", testPackageJson);
+
+      const requiredElseLibVersion = "1.2.3";
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({ matchDependencyVersions: { both: testPackageJson.dependencies!.both, else: requiredElseLibVersion } });
+      expect(addErrorSpy).toHaveBeenCalledTimes(1);
+      expect(readTestPackageJson().devDependencies!.else).toEqual(requiredElseLibVersion);
+    });
+
+    it("Ignores packages that have a correct devDependency version", async () => {
+      const { addErrorSpy, check, host } = makeWorkspace();
+      addPackageJson(host, "./package.json", testPackageJson);
+
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({
+        matchDependencyVersions: {
+          both: testPackageJson.dependencies!.both,
+          greatLib: testPackageJson.dependencies!.greatLib,
+        },
+      });
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("Fixes packages that have an incorrect dependency and devDependency versions", async () => {
+      const { addErrorSpy, check, host } = makeWorkspace(true);
+      const readTestPackageJson = addPackageJson(host, "./package.json", testPackageJson);
+
+      const requiredBothVersion = "1.2.3";
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({ matchDependencyVersions: { both: requiredBothVersion } });
+      expect(addErrorSpy).toHaveBeenCalledTimes(2);
+      expect(readTestPackageJson().dependencies!.both).toEqual(requiredBothVersion);
+      expect(readTestPackageJson().devDependencies!.both).toEqual(requiredBothVersion);
+    });
+  });
+
+  describe("Multiple accepted versions tests", () => {
+    let testPackageJson: PackageJson;
+
+    beforeEach(() => {
+      testPackageJson = {
+        name: "test",
+        dependencies: {
+          greatLib: "^15",
+          both: "1",
+        },
+        peerDependencies: {
+          whatever: "15",
+        },
+        devDependencies: {
+          else: "27.2.1",
+          both: "1",
+        },
+      };
+    });
+
+    it("Accepts a match when multiple versions are configured", async () => {
+      const { addErrorSpy, check, host } = makeWorkspace();
+      addPackageJson(host, "./package.json", testPackageJson);
+
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({ matchDependencyVersions: { greatLib: [testPackageJson.dependencies!.greatLib] } });
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({ matchDependencyVersions: { greatLib: ["1", "2", testPackageJson.dependencies!.greatLib] } });
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({ matchDependencyVersions: { greatLib: ["1", "2", testPackageJson.dependencies!.greatLib, "99", "100"] } });
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({ matchDependencyVersions: { greatLib: [testPackageJson.dependencies!.greatLib, "99", "100"] } });
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("Errors when version does not match", async () => {
+      const { addErrorSpy, check, host } = makeWorkspace();
+      addPackageJson(host, "./package.json", testPackageJson);
+
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({ matchDependencyVersions: { greatLib: ["1", "2"] } });
+      expect(addErrorSpy).toHaveBeenCalledTimes(1);
+      addErrorSpy.mockReset();
+
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+      check({ matchDependencyVersions: { both: ["99", "100"] } });
+      expect(addErrorSpy).toHaveBeenCalledTimes(2);
+      expect(addErrorSpy.mock.calls[0][0].message).toEqual(
+        `Expected dependency on both to match one of '["99","100"]', got '${
+          testPackageJson.dependencies!.both
+        }' instead.`
+      );
+      expect(addErrorSpy.mock.calls[1][0].message).toEqual(
+        `Expected devDependency on both to match one of '["99","100"]', got '${
+          testPackageJson.devDependencies!.both
+        }' instead.`
+      );
+    });
+  });
+});

package/src/__tests__/fileContents.spec.ts

@@ -0,0 +1,74 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+// tslint:disable:no-console
+import { createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils";
+import { AddErrorOptions, Failure } from "@monorepolint/core";
+import { fileContents } from "../fileContents";
+
+const EXPECTED_FOO_FILE = "hello world";
+
+describe.each(HOST_FACTORIES)("fileContents ($name)", (hostFactory) => {
+  describe("fix: true", () => {
+    let workspace: TestingWorkspace;
+    let spy: jest.SpyInstance<void, [AddErrorOptions]>;
+
+    beforeEach(async () => {
+      workspace = await createTestingWorkspace({
+        fixFlag: true,
+        host: hostFactory.make(),
+      });
+      workspace.writeFile("shared/foo-template.txt", EXPECTED_FOO_FILE);
+
+      spy = jest.spyOn(workspace.context, "addError");
+    });
+
+    it("fixes missing file", () => {
+      fileContents.check(workspace.context, {
+        file: "foo.txt",
+        templateFile: "shared/foo-template.txt",
+        generator: undefined,
+        template: undefined,
+      });
+
+      expect(spy).toHaveBeenCalledTimes(1);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "foo.txt",
+          hasFixer: true,
+          message: "Expect file contents to match",
+        })
+      );
+
+      expect(workspace.readFile("foo.txt")).toEqual(EXPECTED_FOO_FILE);
+    });
+
+    it("fixes missing nested file", () => {
+      fileContents.check(workspace.context, {
+        file: "nested/foo.txt",
+        templateFile: "shared/foo-template.txt",
+        generator: undefined,
+        template: undefined,
+      });
+
+      expect(spy).toHaveBeenCalledTimes(1);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "nested/foo.txt",
+          hasFixer: true,
+          message: "Expect file contents to match",
+        })
+      );
+
+      expect(workspace.readFile("nested/foo.txt")).toEqual(EXPECTED_FOO_FILE);
+    });
+  });
+});