Fix tests

Author: paleite

src/processors.test.ts

@@ -1,84 +1,93 @@
-import * as child_process from "child_process";
+jest.mock("./git", () => ({
+  ...jest.requireActual<typeof git>("./git"),
+  getUntrackedFileList: jest.fn(),
+  getDiffFileList: jest.fn(),
+  getDiffForFile: jest.fn(),
+  hasCleanIndex: jest.fn(),
+}));
+
 import type { Linter } from "eslint";
-import { mocked } from "jest-mock";
-import { diff, diffConfig, staged, stagedConfig } from "./processors";
+import * as git from "./git";
 import {
   diff as fixtureDiff,
   staged as fixtureStaged,
 } from "./__fixtures__/diff";
 import { postprocessArguments } from "./__fixtures__/postprocessArguments";
 
-jest.mock("child_process");
-const mockedChildProcess = mocked(child_process, true);
-mockedChildProcess.execFileSync.mockReturnValue(
-  Buffer.from('/mock filename ", ; .js')
-);
-jest.mock("./git", (): unknown => ({
-  ...jest.requireActual("./git"),
-  getDiffFileList: jest
-    .fn()
-    .mockReturnValue(['/mock filename ", ; .js', "README.md"]),
-}));
-
 const [messages, filename] = postprocessArguments;
 
-describe("processors", () => {
-  it("diff preprocess", () => {
-    const validFilename = filename;
-    const sourceCode = "/** Some source code */";
-
-    mockedChildProcess.execFileSync.mockReturnValue(Buffer.from(fixtureDiff));
+const gitMocked: jest.MockedObjectDeep<typeof git> = jest.mocked(git);
+gitMocked.getDiffFileList.mockReturnValue([filename]);
+gitMocked.getUntrackedFileList.mockReturnValue([]);
 
-    expect(diff.preprocess(sourceCode, validFilename)).toEqual([sourceCode]);
-  });
-
-  it("staged preprocess", () => {
+describe("processors", () => {
+  it("preprocess (diff and staged)", async () => {
+    // The preprocessor does not depend on `staged` being true or false, so it's
+    // sufficient to only test one of them.
     const validFilename = filename;
     const sourceCode = "/** Some source code */";
 
-    mockedChildProcess.execFileSync.mockReturnValue(Buffer.from(fixtureDiff));
+    const { diff: diffProcessors } = await import("./processors");
 
-    expect(diff.preprocess(sourceCode, validFilename)).toEqual([sourceCode]);
+    expect(diffProcessors.preprocess(sourceCode, validFilename)).toEqual([
+      sourceCode,
+    ]);
   });
 
-  it("diff postprocess", () => {
-    mockedChildProcess.execFileSync.mockReturnValue(Buffer.from(fixtureDiff));
+  it("diff postprocess", async () => {
+    gitMocked.getDiffForFile.mockReturnValue(fixtureDiff);
 
-    expect(diff.postprocess(messages, filename)).toMatchSnapshot();
+    const { diff: diffProcessors } = await import("./processors");
 
-    expect(mockedChildProcess.execFileSync).toHaveBeenCalled();
+    expect(diffProcessors.postprocess(messages, filename)).toMatchSnapshot();
   });
 
-  it("staged postprocess", () => {
-    mockedChildProcess.execFileSync.mockReturnValue(Buffer.from(fixtureStaged));
+  it("staged postprocess", async () => {
+    gitMocked.hasCleanIndex.mockReturnValueOnce(true);
+    gitMocked.getDiffForFile.mockReturnValueOnce(fixtureStaged);
 
-    expect(staged.postprocess(messages, filename)).toMatchSnapshot();
+    const { staged: stagedProcessors } = await import("./processors");
 
-    expect(mockedChildProcess.execFileSync).toHaveBeenCalled();
+    expect(stagedProcessors.postprocess(messages, filename)).toMatchSnapshot();
   });
 
-  it("should report fatal errors", () => {
-    mockedChildProcess.execFileSync.mockReturnValue(Buffer.from(fixtureDiff));
-
+  it("should report fatal errors", async () => {
+    gitMocked.getDiffForFile.mockReturnValue(fixtureDiff);
     const [[firstMessage, ...restMessage], ...restMessageArray] = messages;
     const messagesWithFatal: Linter.LintMessage[][] = [
       [{ ...firstMessage, fatal: true }, ...restMessage],
       ...restMessageArray,
     ];
 
-    expect(diff.postprocess(messages, filename)).toHaveLength(2);
-    expect(diff.postprocess(messagesWithFatal, filename)).toHaveLength(3);
+    const { diff: diffProcessors } = await import("./processors");
 
-    expect(mockedChildProcess.execFileSync).toHaveBeenCalled();
+    expect(diffProcessors.postprocess(messages, filename)).toHaveLength(2);
+    expect(
+      diffProcessors.postprocess(messagesWithFatal, filename)
+    ).toHaveLength(3);
   });
 });
 
 describe("configs", () => {
-  it("diff", () => {
+  it("diff", async () => {
+    const { diffConfig } = await import("./processors");
     expect(diffConfig).toMatchSnapshot();
   });
 
-  it("staged", () => {
+  it("staged", async () => {
+    const { stagedConfig } = await import("./processors");
     expect(stagedConfig).toMatchSnapshot();
   });
 });
+
+describe("fatal error-message", () => {
+  it("getUnstagedChangesError", async () => {
+    const { getUnstagedChangesError } = await import("./processors");
+
+    const result = getUnstagedChangesError("mock filename.ts")[0];
+    expect(result?.fatal).toBe(true);
+    expect(result?.message).toMatchInlineSnapshot(
+      `"mock filename.ts has unstaged changes. Please stage or remove the changes."`
+    );
+  });
+});

src/processors.ts

@@ -17,15 +17,22 @@ const STAGED = true;
  * them from being processed in the first place, as a performance optimization.
  * This is increasingly useful the more files there are in the repository.
  */
-const getPreProcessor = (staged = false) => {
-  const untrackedFileList = getUntrackedFileList(staged);
-  const diffFileList = getDiffFileList(staged);
-
+const getPreProcessor = (
+  untrackedFileList: string[],
+  diffFileList: string[]
+) => {
   return (text: string, filename: string) => {
     const shouldBeProcessed =
       process.env.VSCODE_CLI !== undefined ||
       diffFileList.includes(filename) ||
       untrackedFileList.includes(filename);
+    // console.error({
+    //   untrackedFileList,
+    //   diffFileList,
+    //   text,
+    //   filename,
+    //   shouldBeProcessed,
+    // });
 
     return shouldBeProcessed ? [text] : [];
   };
@@ -34,6 +41,9 @@ const getPreProcessor = (staged = false) => {
 const isLineWithinRange = (line: number) => (range: Range) =>
   range.isWithinRange(line);
 
+/**
+ * @internal
+ */
 function getUnstagedChangesError(filename: string) {
   // When we only want to diff staged files, but the file is partially
   // staged, the ranges of the staged diff might not match the ranges of the
@@ -55,9 +65,7 @@ function getUnstagedChangesError(filename: string) {
   return [fatalError];
 }
 
-const getPostProcessor = (staged = false) => {
-  const untrackedFileList = getUntrackedFileList(staged);
-
+const getPostProcessor = (untrackedFileList: string[], staged = false) => {
   return (
     messages: Linter.LintMessage[][],
     filename: string
@@ -97,11 +105,16 @@ const getPostProcessor = (staged = false) => {
   };
 };
 
-const getProcessors = (staged = false): Required<Linter.Processor> => ({
-  preprocess: getPreProcessor(staged),
-  postprocess: getPostProcessor(staged),
-  supportsAutofix: true,
-});
+const getProcessors = (staged = false): Required<Linter.Processor> => {
+  const untrackedFileList = getUntrackedFileList(staged);
+  const diffFileList = getDiffFileList(staged);
+
+  return {
+    preprocess: getPreProcessor(untrackedFileList, diffFileList),
+    postprocess: getPostProcessor(untrackedFileList, staged),
+    supportsAutofix: true,
+  };
+};
 
 const diff = getProcessors();
 const staged = getProcessors(STAGED);
@@ -126,4 +139,4 @@ const stagedConfig: Linter.BaseConfig = {
   ],
 };
 
-export { diff, diffConfig, staged, stagedConfig };
+export { diff, diffConfig, staged, stagedConfig, getUnstagedChangesError };