@monorepolint/rules 0.6.0-alpha.4 → 0.6.0-alpha.6

package/src/__tests__/mustSatisfyPeerDependencies.spec.ts

@@ -1301,4 +1301,48 @@ describe("mustSatisfyPeerDependencies", () => {
     expect(addErrorSpy).toHaveBeenCalledTimes(2);
     addErrorSpy.mockReset();
   });
+
+  describe("Options Validation", () => {
+    it("should accept valid options", () => {
+      const ruleModule = mustSatisfyPeerDependencies({ options: {} });
+
+      // Based on the complex union type, {} with all undefined properties is valid
+      expect(() => ruleModule.validateOptions({})).not.toThrow();
+      expect(() =>
+        ruleModule.validateOptions({
+          skipUnparseableRanges: undefined,
+          dependencyWhitelist: undefined,
+          dependencyBlacklist: undefined,
+          enforceForDevDependencies: undefined,
+        })
+      ).not.toThrow();
+      expect(() => ruleModule.validateOptions({ skipUnparseableRanges: true })).not.toThrow();
+      expect(() => ruleModule.validateOptions({ dependencyWhitelist: ["react", "react-dom"] })).not
+        .toThrow();
+      expect(() => ruleModule.validateOptions({ dependencyBlacklist: ["lodash"] })).not.toThrow();
+      expect(() => ruleModule.validateOptions({ enforceForDevDependencies: true })).not.toThrow();
+
+      // Combinations
+      expect(() =>
+        ruleModule.validateOptions({
+          skipUnparseableRanges: true,
+          dependencyWhitelist: ["react"],
+        })
+      ).not.toThrow();
+    });
+
+    it("should reject invalid options", () => {
+      const ruleModule = mustSatisfyPeerDependencies({ options: {} });
+
+      // Note: undefined alone doesn't match any of the union variants
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions(undefined)).toThrow();
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ skipUnparseableRanges: "true" })).toThrow();
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ dependencyWhitelist: "react" })).toThrow();
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ dependencyBlacklist: 123 })).toThrow();
+    });
+  });
 });

package/src/__tests__/nestedWorkspaces.spec.ts

@@ -153,4 +153,18 @@ describe("nestedWorkspaces", () => {
 
     expect((await checkAndSpy()).addErrorSpy).toHaveBeenCalledTimes(0);
   });
+
+  describe("Options Validation", () => {
+    it("should accept undefined options", () => {
+      const ruleModule = nestedWorkspaces({ options: undefined });
+      expect(() => ruleModule.validateOptions(undefined)).not.toThrow();
+    });
+
+    it("should reject non-undefined options", () => {
+      const ruleModule = nestedWorkspaces({ options: undefined });
+      expect(() => ruleModule.validateOptions({})).toThrow();
+      expect(() => ruleModule.validateOptions("string")).toThrow();
+      expect(() => ruleModule.validateOptions([])).toThrow();
+    });
+  });
 });

package/src/__tests__/oncePerPackage.spec.ts

@@ -0,0 +1,75 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { Context } from "@monorepolint/config";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { oncePerPackage } from "../oncePerPackage.js";
+import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils.js";
+
+describe.each(HOST_FACTORIES)("oncePerPackage ($name)", (hostFactory) => {
+  let workspace: TestingWorkspace;
+  let spy: AddErrorSpy;
+  let context: Context;
+
+  beforeEach(async () => {
+    workspace = await createTestingWorkspace({
+      fixFlag: false,
+      host: hostFactory.make(),
+    });
+    context = workspace.context;
+    spy = vi.spyOn(workspace.context, "addError");
+  });
+
+  it("allows first visit to a package", () => {
+    const uniqueKey = `test-key-${Math.random()}`;
+    oncePerPackage({ options: { singletonKey: uniqueKey } }).check(context);
+
+    expect(spy).toHaveBeenCalledTimes(0);
+  });
+
+  it("prevents second visit to the same package with same key", () => {
+    const uniqueKey = `test-key-${Math.random()}`;
+    const rule = oncePerPackage({ options: { singletonKey: uniqueKey } });
+
+    // First visit - should be fine
+    rule.check(context);
+    expect(spy).toHaveBeenCalledTimes(0);
+
+    // Second visit - should error
+    rule.check(context);
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith({
+      message: `This package has already been visited for this key: ${uniqueKey}`,
+      file: context.getPackageJsonPath(),
+    });
+  });
+
+  describe("Options Validation", () => {
+    it("should accept valid options", () => {
+      const ruleModule = oncePerPackage({ options: { singletonKey: "unique-key" } });
+
+      expect(() => ruleModule.validateOptions({ singletonKey: "unique-key" })).not.toThrow();
+      expect(() =>
+        ruleModule.validateOptions({
+          singletonKey: Symbol("unique"),
+          customMessage: "Custom error message",
+        })
+      ).not.toThrow();
+    });
+
+    it("should reject invalid options", () => {
+      const ruleModule = oncePerPackage({ options: { singletonKey: "unique-key" } });
+
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({})).toThrow();
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ singletonKey: 123 })).toThrow();
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ customMessage: "test" })).toThrow();
+    });
+  });
+});

package/src/__tests__/packageEntry.spec.ts

@@ -11,9 +11,11 @@ import { Context, Failure } from "@monorepolint/config";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   createExpectedEntryErrorMessage,
+  createRemovalEntryErrorMessage,
   createStandardizedEntryErrorMessage,
   packageEntry,
 } from "../packageEntry.js";
+import { REMOVE } from "../REMOVE.js";
 import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils.js";
 
 const PACKAGE_MISSING_ENTRY = JSON.stringify(
@@ -54,6 +56,32 @@ const PACKAGE_REPOSITORY = JSON.stringify(
   2,
 ) + "\n";
 
+const PACKAGE_WITH_SCRIPTS = JSON.stringify(
+  {
+    name: "package",
+    version: {},
+    scripts: {
+      build: "tsc",
+      test: "jest",
+    },
+    dependencies: {},
+    license: "UNLICENSED",
+  },
+  undefined,
+  2,
+) + "\n";
+
+const PACKAGE_WITHOUT_SCRIPTS = JSON.stringify(
+  {
+    name: "package",
+    version: {},
+    dependencies: {},
+    license: "UNLICENSED",
+  },
+  undefined,
+  2,
+) + "\n";
+
 describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
   describe("fix: true", () => {
     let workspace: TestingWorkspace;
@@ -208,5 +236,154 @@ describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
 
       expect(workspace.readFile("package.json")).toEqual(PACKAGE_REPOSITORY);
     });
+
+    it("removes existing entries when REMOVE is specified", () => {
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
+
+      packageEntry({
+        options: {
+          entries: {
+            scripts: REMOVE,
+          },
+          entriesExist: undefined,
+        },
+      }).check(context);
+
+      expect(spy).toHaveBeenCalledTimes(1);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: createRemovalEntryErrorMessage("scripts"),
+        }),
+      );
+
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_WITHOUT_SCRIPTS);
+    });
+
+    it("does not error when REMOVE is specified for non-existent entry", () => {
+      workspace.writeFile("package.json", PACKAGE_WITHOUT_SCRIPTS);
+
+      packageEntry({
+        options: {
+          entries: {
+            scripts: REMOVE,
+          },
+          entriesExist: undefined,
+        },
+      }).check(context);
+
+      expect(spy).toHaveBeenCalledTimes(0);
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_WITHOUT_SCRIPTS);
+    });
+
+    it("handles mix of REMOVE and regular entries", () => {
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
+
+      packageEntry({
+        options: {
+          entries: {
+            scripts: REMOVE,
+            description: "A test package",
+          },
+          entriesExist: undefined,
+        },
+      }).check(context);
+
+      expect(spy).toHaveBeenCalledTimes(2);
+
+      const failure1: Failure = spy.mock.calls[0][0];
+      expect(failure1).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: createRemovalEntryErrorMessage("scripts"),
+        }),
+      );
+
+      const failure2: Failure = spy.mock.calls[1][0];
+      expect(failure2).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: createStandardizedEntryErrorMessage("description"),
+        }),
+      );
+
+      const expectedPackage = JSON.stringify(
+        {
+          name: "package",
+          version: {},
+          dependencies: {},
+          license: "UNLICENSED",
+          description: "A test package",
+        },
+        undefined,
+        2,
+      ) + "\n";
+
+      expect(workspace.readFile("package.json")).toEqual(expectedPackage);
+    });
+
+    it("handles REMOVE with entriesExist", () => {
+      workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
+
+      packageEntry({
+        options: {
+          entries: {
+            scripts: REMOVE,
+          },
+          entriesExist: ["license"],
+        },
+      }).check(context);
+
+      expect(spy).toHaveBeenCalledTimes(1);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure).toMatchObject(
+        workspace.failureMatcher({
+          file: "package.json",
+          hasFixer: true,
+          message: createRemovalEntryErrorMessage("scripts"),
+        }),
+      );
+
+      expect(workspace.readFile("package.json")).toEqual(PACKAGE_WITHOUT_SCRIPTS);
+    });
+  });
+
+  describe("Options Validation", () => {
+    it("should accept valid options", () => {
+      const ruleModule = packageEntry({ options: { entries: { name: "@scope/package" } } });
+
+      expect(() =>
+        ruleModule.validateOptions({ entries: { name: "@scope/package", version: "1.0.0" } })
+      ).not.toThrow();
+      expect(() => ruleModule.validateOptions({ entriesExist: ["name", "version"] })).not.toThrow();
+      expect(() =>
+        ruleModule.validateOptions({
+          entries: { license: "MIT" },
+          entriesExist: ["description"],
+        })
+      ).not.toThrow();
+      expect(() =>
+        ruleModule.validateOptions({
+          entries: { scripts: REMOVE, name: "@scope/package" },
+        })
+      ).not.toThrow();
+    });
+
+    it("should reject invalid options", () => {
+      const ruleModule = packageEntry({ options: { entries: { name: "@scope/package" } } });
+
+      expect(() => ruleModule.validateOptions({})).toThrow();
+
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ entriesExist: "name" })).toThrow();
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ entries: "invalid" })).toThrow();
+    });
   });
 });

package/src/__tests__/packageOrder.spec.ts

@@ -182,4 +182,26 @@ describe.each(HOST_FACTORIES)("expectPackageOrder ($name)", (hostFactory) => {
       );
     });
   });
+
+  describe("Options Validation", () => {
+    it("should accept valid options", () => {
+      const ruleModule = packageOrder({ options: undefined });
+
+      expect(() => ruleModule.validateOptions(undefined)).not.toThrow();
+      expect(() => ruleModule.validateOptions({ order: ["name", "version", "scripts"] })).not
+        .toThrow();
+      expect(() =>
+        ruleModule.validateOptions({ order: () => (a: string, b: string) => a.localeCompare(b) })
+      ).not.toThrow();
+    });
+
+    it("should reject invalid options", () => {
+      const ruleModule = packageOrder({ options: undefined });
+
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ order: "name,version" })).toThrow();
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ order: [123, "version"] })).toThrow();
+    });
+  });
 });