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

package/src/__tests__/packageScript.spec.ts

@@ -6,22 +6,16 @@
  */
 
 // tslint:disable:no-console
-import { createMockFiles } from "./utils";
+import { describe, expect, it, beforeEach, jest } from "@jest/globals";
+import { Context, Failure } from "@monorepolint/config";
+import { packageScript } from "../packageScript.js";
+import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils.js";
 
-// done first since this also mocks 'fs'
-const mockFiles: Map<string, string> = createMockFiles();
+const json = (a: unknown) => JSON.stringify(a, undefined, 2) + "\n";
 
-import { Failure, PackageContext } from "@monorepolint/core";
-import { packageScript } from "../packageScript";
-
-const PACKAGE_WITHOUT_SCRIPTS =
-  JSON.stringify(
-    {
-      name: "package-without-scripts",
-    },
-    undefined,
-    2
-  ) + "\n";
+const PACKAGE_WITHOUT_SCRIPTS = json({
+  name: "package-without-scripts",
+});
 
 const MISSING_SCRIPT_NAME = "missing";
 const MISSING_SCRIPT_VALUE = "missing value";
@@ -29,40 +23,31 @@ const MISSING_SCRIPT_VALUE = "missing value";
 const SCRIPT_NAME = "exists";
 const SCRIPT_VALUE = "exists value";
 
-const PACKAGE_WITH_SCRIPTS =
-  JSON.stringify(
-    {
-      name: "package-with-scripts",
-      scripts: {
-        [SCRIPT_NAME]: SCRIPT_VALUE,
-      },
-    },
-    undefined,
-    2
-  ) + "\n";
-
-describe("expectPackageScript", () => {
-  afterEach(() => {
-    mockFiles.clear();
-  });
+const PACKAGE_WITH_SCRIPTS = json({
+  name: "package-with-scripts",
+  scripts: {
+    [SCRIPT_NAME]: SCRIPT_VALUE,
+  },
+});
 
+describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
   describe("fix: false", () => {
-    const context = new PackageContext(".", {
-      rules: [],
-      fix: false,
-      verbose: false,
-    });
+    let workspace: TestingWorkspace;
+    let spy: AddErrorSpy;
 
-    const spy = jest.spyOn(context, "addError");
+    beforeEach(async () => {
+      workspace = await createTestingWorkspace({
+        fixFlag: false,
+        host: hostFactory.make(),
+      });
 
-    afterEach(() => {
-      spy.mockClear();
+      spy = jest.spyOn(workspace.context, "addError");
     });
 
     it("handles an empty script section", () => {
-      mockFiles.set("package.json", PACKAGE_WITHOUT_SCRIPTS);
+      workspace.writeFile("package.json", PACKAGE_WITHOUT_SCRIPTS);
 
-      packageScript.check(context, {
+      packageScript.check(workspace.context, {
         scripts: {
           foo: "bar",
         },
@@ -71,26 +56,33 @@ describe("expectPackageScript", () => {
       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("No scripts block in package.json");
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: "No scripts block in package.json",
+        })
+      );
     });
   });
 
   describe("fix: true", () => {
-    const context = new PackageContext(".", {
-      rules: [],
-      fix: true,
-      verbose: false,
-    });
-    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(),
+      });
 
-    afterEach(() => {
-      spy.mockClear();
+      spy = jest.spyOn(workspace.context, "addError");
+      context = workspace.context; // minimizing delta
     });
 
     it("fixes an empty script section", () => {
-      mockFiles.set("package.json", PACKAGE_WITHOUT_SCRIPTS);
+      workspace.writeFile("package.json", PACKAGE_WITHOUT_SCRIPTS);
 
       packageScript.check(context, {
         scripts: {
@@ -101,15 +93,19 @@ describe("expectPackageScript", () => {
       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("No scripts block in package.json");
-
-      expect(JSON.parse(mockFiles.get("package.json")!).scripts).toEqual({});
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: "No scripts block in package.json",
+        })
+      );
+
+      expect(JSON.parse(workspace.readFile("package.json")!).scripts).toEqual({});
     });
 
     it("adds a script", () => {
-      mockFiles.set("package.json", PACKAGE_WITH_SCRIPTS);
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
       packageScript.check(context, {
         scripts: {
@@ -120,15 +116,23 @@ describe("expectPackageScript", () => {
       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 script entry for '${MISSING_SCRIPT_NAME}'`);
-
-      expect(JSON.parse(mockFiles.get("package.json")!).scripts[MISSING_SCRIPT_NAME]).toEqual(MISSING_SCRIPT_VALUE);
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: expect.stringContaining(
+            `Expected standardized script entry for '${MISSING_SCRIPT_NAME}'`
+          ) as any as string,
+        })
+      );
+
+      expect(JSON.parse(workspace.readFile("package.json")!).scripts[MISSING_SCRIPT_NAME]).toEqual(
+        MISSING_SCRIPT_VALUE
+      );
     });
 
     it("does nothing if the value exists", () => {
-      mockFiles.set("package.json", PACKAGE_WITH_SCRIPTS);
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
       packageScript.check(context, {
         scripts: {
@@ -138,9 +142,89 @@ describe("expectPackageScript", () => {
 
       expect(spy).not.toHaveBeenCalled();
 
-      expect(JSON.parse(mockFiles.get("package.json")!).scripts).toEqual({
+      expect(JSON.parse(workspace.readFile("package.json")!).scripts).toEqual({
         [SCRIPT_NAME]: SCRIPT_VALUE,
       });
     });
+
+    it("errors if long form is used and no value matches and there is no fixValue", () => {
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
+
+      packageScript.check(context, {
+        scripts: {
+          foo: {
+            options: ["a", "b"],
+          },
+        },
+      });
+
+      const errors = spy.mock.calls;
+
+      expect(errors.length).toBe(1);
+      expect(errors[0][0].fixer).toBeUndefined();
+    });
+
+    it("uses the fixValue for fixing if provided", () => {
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
+
+      packageScript.check(context, {
+        scripts: {
+          foo: {
+            options: ["a", "b"],
+            fixValue: "a",
+          },
+        },
+      });
+
+      const errors = spy.mock.calls;
+
+      expect(errors.length).toBe(1);
+      expect(errors[0][0].fixer).toBeDefined();
+
+      expect(JSON.parse(workspace.readFile("package.json")!).scripts).toEqual({
+        [SCRIPT_NAME]: SCRIPT_VALUE,
+        foo: "a",
+      });
+    });
+
+    it("can fix to empty", () => {
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
+
+      packageScript.check(context, {
+        scripts: {
+          [SCRIPT_NAME]: {
+            options: ["a", undefined],
+            fixValue: undefined,
+          },
+        },
+      });
+
+      const errors = spy.mock.calls;
+
+      expect(errors.length).toBe(1);
+      expect(errors[0][0].fixer).toBeDefined();
+
+      expect(JSON.parse(workspace.readFile("package.json")!).scripts).toEqual({});
+    });
+
+    it("can allow only empty", () => {
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
+
+      packageScript.check(context, {
+        scripts: {
+          [SCRIPT_NAME]: {
+            options: [undefined],
+            fixValue: undefined,
+          },
+        },
+      });
+
+      const errors = spy.mock.calls;
+
+      expect(errors.length).toBe(1);
+      expect(errors[0][0].fixer).toBeDefined();
+
+      expect(JSON.parse(workspace.readFile("package.json")!).scripts).toEqual({});
+    });
   });
 });

package/src/__tests__/requireDependency.spec.ts

@@ -0,0 +1,152 @@
+/*!
+ * 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 { readFileSync, writeFileSync } from "node:fs";
+import * as path from "node:path";
+import * as tmp from "tmp";
+import { requireDependency } from "../requireDependency.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: {
+    packages: ["packages/*"],
+  },
+  dependencies: {
+    foo: "5",
+  },
+});
+
+const PACKAGE_WITH_NO_ENTRIES = jsonToString({});
+
+const PACKAGE_WITH_ENTRIES_MISSING = jsonToString({
+  dependencies: {},
+  devDependencies: {},
+});
+
+const PACKAGE_WITH_WRONG_ENTRIES = jsonToString({
+  dependencies: {
+    foo: "0.1.0",
+  },
+  devDependencies: {
+    bar: "1.0.0",
+  },
+});
+
+const PACKAGE_WITH_RIGHT_ENTRIES = jsonToString({
+  dependencies: {
+    foo: "1.0.0",
+  },
+  devDependencies: {
+    bar: "^2.0.0",
+  },
+});
+
+const OPTIONS = {
+  dependencies: {
+    foo: "1.0.0",
+  },
+  devDependencies: {
+    bar: "^2.0.0",
+  },
+} as const;
+
+const CORRECT_OUTPUT = jsonToString(OPTIONS);
+
+describe("requireDependency", () => {
+  tmp.setGracefulCleanup();
+
+  let cleanupJobs: Array<() => void> = [];
+
+  afterEach(() => {
+    for (const cleanupJob of cleanupJobs) {
+      cleanupJob();
+    }
+    cleanupJobs = [];
+  });
+
+  function makeWorkspace({ fix }: { fix: boolean }) {
+    const dir: tmp.DirResult = tmp.dirSync({ unsafeCleanup: true });
+    cleanupJobs.push(() => dir.removeCallback());
+
+    const workspaceContext = new WorkspaceContextImpl(
+      dir.name,
+      {
+        rules: [],
+        fix,
+        verbose: false,
+        silent: true,
+      },
+      new SimpleHost()
+    );
+
+    function checkAndSpy(q: string) {
+      const context = workspaceContext.createChildContext(path.resolve(dir.name, q));
+      const addErrorSpy = jest.spyOn(context, "addError");
+      requireDependency.check(context, OPTIONS);
+      return { context, addErrorSpy };
+    }
+
+    function addFile(filePath: string, content: string) {
+      const dirPath = path.resolve(dir.name, path.dirname(filePath));
+      const resolvedFilePath = path.resolve(dir.name, filePath);
+
+      makeDirectoryRecursively(dirPath);
+      writeFileSync(resolvedFilePath, content);
+    }
+
+    function readFile(filePath: string) {
+      return readFileSync(path.resolve(dir.name, filePath)).toString();
+    }
+
+    return { addFile, readFile, workspaceContext, checkAndSpy };
+  }
+
+  it("checks correctly", () => {
+    const { addFile, workspaceContext, checkAndSpy } = makeWorkspace({ fix: false });
+    addFile("./package.json", PACKAGE_ROOT);
+    addFile("./packages/none/package.json", PACKAGE_WITH_NO_ENTRIES);
+    addFile("./packages/missing/package.json", PACKAGE_WITH_ENTRIES_MISSING);
+    addFile("./packages/wrong/package.json", PACKAGE_WITH_WRONG_ENTRIES);
+    addFile("./packages/right/package.json", PACKAGE_WITH_RIGHT_ENTRIES);
+
+    requireDependency.check(workspaceContext, OPTIONS);
+
+    const none = checkAndSpy("./packages/none");
+    expect(none.addErrorSpy).toHaveBeenCalledTimes(2);
+
+    const missing = checkAndSpy("./packages/missing");
+    expect(missing.addErrorSpy).toHaveBeenCalledTimes(2);
+
+    const wrong = checkAndSpy("./packages/wrong");
+    expect(wrong.addErrorSpy).toHaveBeenCalledTimes(2);
+
+    const right = checkAndSpy("./packages/right");
+    expect(right.addErrorSpy).toHaveBeenCalledTimes(0);
+  });
+
+  it("fixes correctly", () => {
+    const { addFile, readFile, checkAndSpy } = makeWorkspace({ fix: true });
+    addFile("./package.json", PACKAGE_ROOT);
+    addFile("./packages/missing/package.json", PACKAGE_WITH_ENTRIES_MISSING);
+    addFile("./packages/wrong/package.json", PACKAGE_WITH_WRONG_ENTRIES);
+
+    const missing = checkAndSpy("./packages/missing");
+    expect(missing.addErrorSpy).toHaveBeenCalledTimes(2);
+
+    const wrong = checkAndSpy("./packages/wrong");
+    expect(wrong.addErrorSpy).toHaveBeenCalledTimes(2);
+
+    const missingContents = readFile("./packages/missing/package.json");
+    expect(missingContents).toEqual(CORRECT_OUTPUT);
+
+    const contents = readFile("./packages/wrong/package.json");
+    expect(contents).toEqual(CORRECT_OUTPUT);
+  });
+});

package/src/__tests__/utils.ts

@@ -5,19 +5,123 @@
  *
  */
 
-export function createMockFiles() {
-  const mockFiles: Map<string, string> = new Map();
+import { AddErrorOptions, WorkspaceContext } from "@monorepolint/config";
+import { WorkspaceContextImpl } from "@monorepolint/core";
+import { CachingHost, Host, SimpleHost } from "@monorepolint/utils";
+import { expect, jest } from "@jest/globals";
+import * as path from "node:path";
+import * as tmp from "tmp";
 
-  jest.mock("fs", () => ({
-    writeFileSync: function writeFileSync(filePath: string, contents: string) {
-      mockFiles.set(filePath, contents);
-    },
+export function jsonToString(obj: unknown) {
+  return JSON.stringify(obj, undefined, 2) + "\n";
+}
+
+interface TestingWorkspaceOpts {
+  host: Host;
+  rootProjectName?: string;
+  fixFlag: boolean;
+}
+
+export async function createTestingWorkspace(inboundOpts: TestingWorkspaceOpts) {
+  tmp.setGracefulCleanup();
+  const tmpdir = tmp.dirSync();
+  const opts = {
+    ...inboundOpts,
+    rootProjectName: inboundOpts.rootProjectName ?? "rootProject",
+  };
+  const rootPath = tmpdir.name;
+  opts.host.mkdir(rootPath, { recursive: true });
 
-    // tslint:disable-next-line: variable-name
-    readFileSync: function readFileSync(filePath: string, _contentType: string) {
-      return mockFiles.get(filePath);
+  opts.host.writeJson(path.join(rootPath, "package.json"), {
+    name: opts.rootProjectName,
+    workspaces: {
+      packages: ["packages/*"],
     },
-  }));
+  });
+
+  await opts.host.flush();
 
-  return mockFiles;
+  return new DefaultTestingWorkspace(
+    { ...opts, rootPath },
+    new WorkspaceContextImpl(rootPath, { fix: opts.fixFlag, rules: [] }, opts.host)
+  );
 }
+
+interface RealTestingWorkspaceOpts extends Required<TestingWorkspaceOpts> {
+  rootPath: string;
+}
+
+export interface TestingWorkspace {
+  /**
+   * Adds a utf8 file to `packageName` with `relativePath` to the package directory.
+   *
+   * @param packageName The child package to add to or undefined for root package
+   * @param filePath The path of the file to be written. Will be prepended with package dir
+   * @param contents the contents to be written (as utf8)
+   */
+  writeFile(filePath: string, contents: string): void;
+
+  writeJsonFile(filePath: string, json: object): void;
+  addProject(name: string, fields: object): void;
+  getFilePath(filePath: string): string;
+  readFile(filePath: string): string;
+
+  /**
+   * Helper method for matching failures via jest `expect().toMatchObject
+   *
+   */
+  failureMatcher(opts: { file: string; message: string; hasFixer: boolean }): any;
+
+  readonly context: WorkspaceContext;
+}
+
+class DefaultTestingWorkspace implements TestingWorkspace {
+  constructor(private opts: RealTestingWorkspaceOpts, public readonly context: WorkspaceContext) {}
+
+  addProject(name: string, fields: object) {
+    this.writeJsonFile(path.join("packages", name, "package.json"), {
+      name,
+      ...fields,
+    });
+  }
+
+  writeJsonFile(filePath: string, json: object) {
+    this.writeFile(filePath, JSON.stringify(json, undefined, 2));
+  }
+
+  /**
+   * Adds a utf8 file to `packageName` with `relativePath` to the package directory.
+   *
+   * @param packageName The child package to add to or undefined for root package
+   * @param filePath The path of the file to be written. Will be prepended with package dir
+   * @param contents the contents to be written (as utf8)
+   */
+  writeFile(filePath: string, contents: string) {
+    const fullFilePath = this.getFilePath(filePath);
+    this.opts.host.mkdir(path.dirname(fullFilePath), { recursive: true });
+    this.opts.host.writeFile(fullFilePath, contents, { encoding: "utf-8" });
+  }
+
+  getFilePath(filePath: string) {
+    return path.join(this.opts.rootPath, filePath);
+  }
+
+  readFile(filePath: string) {
+    return this.opts.host.readFile(this.getFilePath(filePath), { encoding: "utf-8" });
+  }
+
+  failureMatcher(opts: { file: string; message: string; hasFixer: boolean }) {
+    return {
+      file: this.getFilePath(opts.file),
+      message: opts.message,
+      ...(opts.hasFixer ? { fixer: expect.any(Function) } : {}),
+    };
+  }
+}
+
+export type AddErrorSpy = jest.SpiedFunction<(options: AddErrorOptions) => void>;
+
+export const HOST_FACTORIES: Array<{ name: string; make: () => Host }> = [
+  { name: "SimpleHost", make: () => new SimpleHost() },
+  { name: "CachingHost", make: () => new CachingHost() },
+];

package/src/alphabeticalDependencies.ts

@@ -5,61 +5,19 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/core";
-import { writeJson } from "@monorepolint/utils";
-import diff from "jest-diff";
+import { Context, RuleModule } from "@monorepolint/config";
 import * as r from "runtypes";
-
+import { checkAlpha } from "./util/checkAlpha.js";
+import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
 const Options = r.Undefined;
 
-export const alphabeticalDependencies = {
+export const alphabeticalDependencies: RuleModule<typeof Options> = {
   check: function expectAlphabeticalDependencies(context: Context) {
     checkAlpha(context, "dependencies");
     checkAlpha(context, "devDependencies");
     checkAlpha(context, "peerDependencies");
   },
   optionsRuntype: Options,
-} as RuleModule<typeof Options>;
-
-function checkAlpha(context: Context, block: "dependencies" | "devDependencies" | "peerDependencies") {
-  const packageJson = context.getPackageJson();
-  const packagePath = context.getPackageJsonPath();
-
-  const dependencies = packageJson[block];
-
-  if (dependencies === undefined) {
-    return;
-  }
-
-  const actualOrder = Object.keys(dependencies);
-  const expectedOrder = actualOrder.slice().sort(); // sort mutates, so we need to copy the previous result
-
-  if (!arrayOrderCompare(actualOrder, expectedOrder)) {
-    context.addError({
-      file: packagePath,
-      message: `Incorrect order of ${block} in package.json`,
-      longMessage: diff(expectedOrder, actualOrder, { expand: true }),
-      fixer: () => {
-        const expectedDependencies: Record<string, string> = {};
-
-        expectedOrder.forEach(dep => {
-          expectedDependencies[dep] = dependencies[dep];
-        });
-
-        const newPackageJson = { ...packageJson };
-        newPackageJson[block] = expectedDependencies;
-        writeJson(packagePath, newPackageJson);
-      },
-    });
-  }
-}
-
-function arrayOrderCompare(a: ReadonlyArray<string>, b: ReadonlyArray<string>) {
-  for (let index = 0; index < a.length; index++) {
-    if (a[index] !== b[index]) {
-      return false;
-    }
-  }
+};
 
-  return true;
-}
+export const AlphabeticalDependencies = createNewRuleConversion("AlphabetialDependencies", alphabeticalDependencies);

package/src/alphabeticalScripts.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { Context, RuleModule } from "@monorepolint/config";
+import * as r from "runtypes";
+import { checkAlpha } from "./util/checkAlpha.js";
+import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
+const Options = r.Undefined;
+
+export const alphabeticalScripts: RuleModule<typeof Options> = {
+  check: function expectAlphabeticalScripts(context: Context) {
+    checkAlpha(context, "scripts");
+  },
+  optionsRuntype: Options,
+};
+
+export const AlphabeticalScripts = createNewRuleConversion("AlphabeticalScripts", alphabeticalScripts);