@monorepolint/rules 0.5.0-alpha.82 → 0.5.0-alpha.85

package/src/__tests__/packageOrder.spec.ts

@@ -6,12 +6,8 @@
  */
 
 // 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 { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils";
+import { Context, Failure } from "@monorepolint/core";
 import { packageOrder } from "../packageOrder";
 
 const PACKAGE_UNORDERED =
@@ -85,26 +81,24 @@ 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,
@@ -113,15 +107,19 @@ describe("expectPackageOrder", () => {
       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,
@@ -130,15 +128,19 @@ describe("expectPackageOrder", () => {
       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,
@@ -147,15 +149,19 @@ describe("expectPackageOrder", () => {
       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,
@@ -163,7 +169,7 @@ describe("expectPackageOrder", () => {
 
       expect(spy).not.toHaveBeenCalled();
 
-      expect(mockFiles.get("package.json")).toEqual(PACKAGE_ORDERED_UNKOWN_KEYS);
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_ORDERED_UNKOWN_KEYS);
     });
   });
 });

package/src/__tests__/packageScript.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 { Failure, PackageContext } from "@monorepolint/core";
+import { Context, Failure } from "@monorepolint/core";
 import { packageScript } from "../packageScript";
+import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils";
 
 const json = (a: unknown) => JSON.stringify(a, undefined, 2) + "\n";
 
@@ -33,29 +30,24 @@ const PACKAGE_WITH_SCRIPTS = json({
   },
 });
 
-describe("expectPackageScript", () => {
-  afterEach(() => {
-    mockFiles.clear();
-  });
-
+describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
   describe("fix: false", () => {
-    const context = new PackageContext(".", {
-      rules: [],
-      fix: false,
-      verbose: false,
-      silent: true,
-    });
+    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",
         },
@@ -64,27 +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,
-      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(),
+      });
 
-    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: {
@@ -95,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: {
@@ -114,15 +116,21 @@ 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).toMatch(`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}'`),
+        })
+      );
+
+      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: {
@@ -132,13 +140,13 @@ 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", () => {
-      mockFiles.set("package.json", PACKAGE_WITH_SCRIPTS);
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
       packageScript.check(context, {
         scripts: {
@@ -155,7 +163,7 @@ describe("expectPackageScript", () => {
     });
 
     it("uses the fixValue for fixing if provided", () => {
-      mockFiles.set("package.json", PACKAGE_WITH_SCRIPTS);
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
       packageScript.check(context, {
         scripts: {
@@ -171,14 +179,14 @@ describe("expectPackageScript", () => {
       expect(errors.length).toBe(1);
       expect(errors[0][0].fixer).toBeDefined();
 
-      expect(JSON.parse(mockFiles.get("package.json")!).scripts).toEqual({
+      expect(JSON.parse(workspace.readFile("package.json")!).scripts).toEqual({
         [SCRIPT_NAME]: SCRIPT_VALUE,
         foo: "a",
       });
     });
 
     it("can fix to empty", () => {
-      mockFiles.set("package.json", PACKAGE_WITH_SCRIPTS);
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
       packageScript.check(context, {
         scripts: {
@@ -194,11 +202,11 @@ describe("expectPackageScript", () => {
       expect(errors.length).toBe(1);
       expect(errors[0][0].fixer).toBeDefined();
 
-      expect(JSON.parse(mockFiles.get("package.json")!).scripts).toEqual({});
+      expect(JSON.parse(workspace.readFile("package.json")!).scripts).toEqual({});
     });
 
     it("can allow only empty", () => {
-      mockFiles.set("package.json", PACKAGE_WITH_SCRIPTS);
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
       packageScript.check(context, {
         scripts: {
@@ -214,7 +222,7 @@ describe("expectPackageScript", () => {
       expect(errors.length).toBe(1);
       expect(errors[0][0].fixer).toBeDefined();
 
-      expect(JSON.parse(mockFiles.get("package.json")!).scripts).toEqual({});
+      expect(JSON.parse(workspace.readFile("package.json")!).scripts).toEqual({});
     });
   });
 });

package/src/__tests__/requireDependency.spec.ts

@@ -5,6 +5,7 @@
  *
  */
 import { WorkspaceContext } from "@monorepolint/core";
+import { SimpleHost } from "@monorepolint/utils";
 import { readFileSync, writeFileSync } from "fs";
 import * as path from "path";
 import * as tmp from "tmp";
@@ -73,12 +74,16 @@ describe("requireDependency", () => {
     const dir: tmp.DirResult = tmp.dirSync({ unsafeCleanup: true });
     cleanupJobs.push(() => dir.removeCallback());
 
-    const workspaceContext = new WorkspaceContext(dir.name, {
-      rules: [],
-      fix,
-      verbose: false,
-      silent: true,
-    });
+    const workspaceContext = new WorkspaceContext(
+      dir.name,
+      {
+        rules: [],
+        fix,
+        verbose: false,
+        silent: true,
+      },
+      new SimpleHost()
+    );
 
     function checkAndSpy(q: string) {
       const context = workspaceContext.createChildContext(path.resolve(dir.name, q));

package/src/__tests__/utils.ts

@@ -5,31 +5,121 @@
  *
  */
 
-export function createMockFiles() {
-  const mockFiles: Map<string, string> = new Map();
+import { AddErrorOptions, WorkspaceContext } from "@monorepolint/core";
+import { CachingHost, Host, SimpleHost } from "@monorepolint/utils";
+import * as path from "path";
+import * as tmp from "tmp";
 
-  jest.mock("fs", () => ({
-    writeFileSync: function writeFileSync(filePath: string, contents: string) {
-      mockFiles.set(filePath, contents);
-    },
+export function jsonToString(obj: {}) {
+  return JSON.stringify(obj, undefined, 2) + "\n";
+}
 
-    // tslint:disable-next-line: variable-name
-    readFileSync: function readFileSync(filePath: string, _contentType: string) {
-      return mockFiles.get(filePath);
-    },
+interface TestingWorkspaceOpts {
+  host: Host;
+  rootProjectName?: string;
+  fixFlag: boolean;
+}
 
-    existsSync: function existsSync(filePath: string) {
-      return mockFiles.has(filePath);
-    },
+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 });
 
-    mkdirSync: function mkdirSync(directoryPath: string) {
-      return mockFiles.set(directoryPath, "");
+  opts.host.writeJson(path.join(rootPath, "package.json"), {
+    name: opts.rootProjectName,
+    workspaces: {
+      packages: ["packages/*"],
     },
-  }));
+  });
 
-  return mockFiles;
+  await opts.host.flush();
+
+  return new DefaultTestingWorkspace(
+    { ...opts, rootPath },
+    new WorkspaceContext(rootPath, { fix: opts.fixFlag, rules: [] }, opts.host)
+  );
 }
 
-export function jsonToString(obj: {}) {
-  return JSON.stringify(obj, undefined, 2) + "\n";
+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.SpyInstance<void, [AddErrorOptions]>;
+
+export const HOST_FACTORIES: Array<{ name: string; make: () => Host }> = [
+  { name: "SimpleHost", make: () => new SimpleHost() },
+  { name: "CachingHost", make: () => new CachingHost() },
+];