@monorepolint/rules 0.5.0-alpha.7 → 0.5.0-alpha.70

package/src/__tests__/consistentVersions.spec.ts

@@ -0,0 +1,218 @@
+/*!
+ * 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 { PackageJson, readJson, writeJson } 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 workspaceContext = new WorkspaceContext(cwd!, {
+      rules: [],
+      fix,
+      verbose: false,
+      silent: true,
+    });
+    const addErrorSpy = jest.spyOn(workspaceContext, "addError");
+
+    function check(options: Options = { matchDependencyVersions: {} }) {
+      consistentVersions.check(workspaceContext, options);
+    }
+
+    return { addErrorSpy, check };
+  }
+
+  function addPackageJson(filePath: string, packageJson: PackageJson) {
+    const dirPath = path.resolve(cwd!, path.dirname(filePath));
+    const resolvedFilePath = path.resolve(cwd!, filePath);
+
+    makeDirectoryRecursively(dirPath);
+    writeJson(resolvedFilePath, packageJson);
+    return (): PackageJson => {
+      return 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 } = makeWorkspace();
+      addPackageJson("./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 } = makeWorkspace(true);
+      const readTestPackageJson = addPackageJson("./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 } = makeWorkspace();
+      addPackageJson("./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 } = makeWorkspace(true);
+      const readTestPackageJson = addPackageJson("./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 } = makeWorkspace();
+      addPackageJson("./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 } = makeWorkspace(true);
+      const readTestPackageJson = addPackageJson("./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 } = makeWorkspace();
+      addPackageJson("./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 } = makeWorkspace();
+      addPackageJson("./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,82 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+// 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 * as path from "path";
+import { fileContents } from "../fileContents";
+
+const EXPECTED_FOO_FILE = "hello world";
+
+describe("fileContents", () => {
+  afterEach(() => {
+    mockFiles.clear();
+  });
+
+  describe("fix: true", () => {
+    const context = new PackageContext(".", {
+      rules: [],
+      fix: true,
+      verbose: false,
+      silent: true,
+    });
+    const spy = jest.spyOn(context, "addError");
+
+    afterEach(() => {
+      spy.mockClear();
+    });
+
+    it("fixes missing file", () => {
+      mockFiles.set(path.resolve(context.getWorkspaceContext().packageDir, "foo-template.txt"), EXPECTED_FOO_FILE);
+
+      fileContents.check(context, {
+        file: "foo.txt",
+        templateFile: "foo-template.txt",
+        generator: undefined,
+        template: undefined,
+      });
+
+      expect(spy).toHaveBeenCalledTimes(1);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure.file).toBe("foo.txt");
+      expect(failure.fixer).not.toBeUndefined();
+      expect(failure.message).toBe("Expect file contents to match");
+
+      expect(mockFiles.get("foo.txt")).toEqual(EXPECTED_FOO_FILE);
+    });
+
+    it("fixes missing nested file", () => {
+      mockFiles.set(
+        path.resolve(context.getWorkspaceContext().packageDir, "shared/foo-template.txt"),
+        EXPECTED_FOO_FILE
+      );
+
+      fileContents.check(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.file).toBe("nested/foo.txt");
+      expect(failure.fixer).not.toBeUndefined();
+      expect(failure.message).toBe("Expect file contents to match");
+
+      expect(mockFiles.get("nested")).not.toBeUndefined();
+      expect(mockFiles.get("nested/foo.txt")).toEqual(EXPECTED_FOO_FILE);
+    });
+  });
+});