@monorepolint/rules 0.5.0-alpha.10 → 0.5.0-alpha.103

package/package.json

@@ -1,38 +1,57 @@
 {
   "name": "@monorepolint/rules",
-  "version": "0.5.0-alpha.10+b584a18",
+  "version": "0.5.0-alpha.103+241c1b6",
   "author": "Eric L Anderson (https://github.com/ericanderson)",
   "contributors": [
     "Mac Lockard (https://github.com/maclockard)"
   ],
   "url": "https://github.com/monorepolint/monorepolint",
   "license": "MIT",
-  "main": "lib/index.js",
-  "typings": "lib/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./build/types/index.d.ts",
+      "import": "./build/js/index.js",
+      "require": "./build/js/index.cjs"
+    }
+  },
   "scripts": {
-    "clean": "rm -rf build lib node_modules *.tgz",
-    "compile:typescript": "../../node_modules/.bin/tsc",
-    "jest:watch": "../../node_modules/.bin/jest --config ../../jest.config.js --watch",
-    "jest": "../../node_modules/.bin/jest --config ../../jest.config.js",
-    "lint:typescript": "../../node_modules/.bin/tslint --config ../../tslint.json --project .",
-    "test:watch": "../../node_modules/.bin/jest --colors --passWithNoTests --watch",
-    "test": "../../node_modules/.bin/jest --colors --passWithNoTests"
+    "clean": "rm -rf build dist lib node_modules *.tgz tsconfig.tsbuildinfo",
+    "compile-typescript": "tsc --build",
+    "lint": "eslint .",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --colors --passWithNoTests",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --colors --passWithNoTests --watch",
+    "transpile-typescript": "tsup --config ../../tsup.config.cjs"
   },
   "dependencies": {
-    "@monorepolint/core": "^0.5.0-alpha.10+b584a18",
-    "@monorepolint/utils": "^0.5.0-alpha.10+b584a18",
-    "jest-diff": "^24.9.0",
-    "minimatch": "^3.0.4",
-    "runtypes": "^4.0.0"
+    "@monorepolint/config": "^0.5.0-alpha.103+241c1b6",
+    "@monorepolint/core": "^0.5.0-alpha.103+241c1b6",
+    "@monorepolint/utils": "^0.5.0-alpha.103+241c1b6",
+    "globby": "^13.1.2",
+    "jest-diff": "^29.3.1",
+    "resolve-package-path": "^4.0.3",
+    "runtypes": "^6.6.0",
+    "semver": "^7.3.8",
+    "tslib": "^2.3.1"
   },
   "devDependencies": {
-    "@types/jest-diff": "^20.0.0",
-    "@types/minimatch": "^3.0.3",
-    "@types/tmp": "^0.1.0",
-    "tmp": "^0.1.0"
+    "@jest/globals": "^29.3.1",
+    "@types/jest": "^29.2.4",
+    "@types/semver": "^7.3.13",
+    "@types/tmp": "^0.2.3",
+    "@typescript-eslint/eslint-plugin": "^5.45.1",
+    "@typescript-eslint/parser": "^5.45.1",
+    "eslint": "^8.29.0",
+    "jest": "^29.3.1",
+    "prettier": "^2.8.0",
+    "tmp": "^0.2.1",
+    "ts-jest": "^29.0.3",
+    "tslib": "^2.4.1",
+    "tsup": "^6.5.0",
+    "typescript": "^4.9.3"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b584a18e553330f84b64afd3a658342cab6c7234"
+  "gitHead": "241c1b6bcf55ee188dd2ee3f652de4c91e0817aa"
 }

package/src/__tests__/alphabeticalScripts.spec.ts

@@ -0,0 +1,76 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+// tslint:disable:no-console
+import { describe, expect, it, beforeEach, jest } from "@jest/globals";
+import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, jsonToString, TestingWorkspace } from "./utils.js";
+import { Context, Failure } from "@monorepolint/config";
+import { alphabeticalScripts } from "../alphabeticalScripts.js";
+import { createIncorrectOrderErrorMessage } from "../util/checkAlpha.js";
+
+const PACKAGE_SCRIPTS_SORTED = jsonToString({
+  name: "foo-lib",
+  scripts: {
+    a: "a-",
+    b: "b-",
+    c: "c-",
+  },
+});
+
+const PACKAGE_SCRIPTS_UNSORTED = jsonToString({
+  name: "foo-lib",
+  scripts: {
+    c: "c-",
+    a: "a-",
+    b: "b-",
+  },
+});
+
+describe.each(HOST_FACTORIES)("alphabeticalScripts ($name)", (hostFactory) => {
+  describe("fix: 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");
+    });
+
+    it("fixes unsorted scripts", () => {
+      workspace.writeFile("package.json", PACKAGE_SCRIPTS_UNSORTED);
+
+      alphabeticalScripts.check(context, undefined);
+
+      expect(spy).toHaveBeenCalledTimes(1);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: createIncorrectOrderErrorMessage("scripts", "foo-lib"),
+        })
+      );
+
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_SCRIPTS_SORTED);
+    });
+
+    it("does nothing if already sorted", () => {
+      workspace.writeFile("package.json", PACKAGE_SCRIPTS_SORTED);
+
+      alphabeticalScripts.check(context, undefined);
+
+      expect(spy).toHaveBeenCalledTimes(0);
+    });
+  });
+});

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 { describe, expect, it, beforeEach, jest, afterEach } from "@jest/globals";
+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 { bannedDependencies, Options } from "../bannedDependencies.js";
+import { makeDirectoryRecursively } from "../util/makeDirectory.js";
+import { jsonToString } from "./utils.js";
+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 WorkspaceContextImpl(
+      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

@@ -4,15 +4,15 @@
  * Licensed under the MIT license. See LICENSE file in the project root for details.
  *
  */
-import { WorkspaceContext } from "@monorepolint/core";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { WorkspaceContextImpl } from "@monorepolint/core";
+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.js";
+import { makeDirectoryRecursively } from "../util/makeDirectory.js";
+import { jsonToString } from "./utils.js";
+import { describe, expect, it, afterEach, jest } from "@jest/globals";
 
 const PACKAGE_ROOT = jsonToString({
   workspaces: {
@@ -29,6 +29,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 +60,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 WorkspaceContextImpl(
+      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 +85,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 +100,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 +109,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 +130,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,224 @@
+/*!
+ * Copyright 2020 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { WorkspaceContextImpl } 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.js";
+import { makeDirectoryRecursively } from "../util/makeDirectory.js";
+import { describe, expect, it, beforeEach, afterEach, jest } from "@jest/globals";
+
+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 WorkspaceContextImpl(
+      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.`
+      );
+    });
+  });
+});