Add cwd arg and cwd behavior (#1305)

## Summary: This adds a new `--cwd` argument to override the current working directory that checksync uses. More importantly, it now sets the current working directory to the location of the configuration file, if one is loaded. This ensures that paths/globs specified in a configuration file are interpreted relative to the configuration file, not the current working directory, which makes it a lot easier to reason about the configuration file definition. Issue: fixes #1262 ## Test plan: `yarn test` Author: somewhatabstract Reviewers: jeremywiebe, kevinbarabash Required Reviewers: Approved By: Checks: ✅ CodeQL, ✅ codecov/project, ✅ Test and build (macOS-latest, 18.x), ✅ Test and build (macOS-latest, 16.x), ✅ Test and build (ubuntu-latest, 18.x), ✅ Test and build (ubuntu-latest, 16.x), ✅ Test and build (windows-latest, 18.x), ✅ Test and build (windows-latest, 16.x), ✅ Integration tests (windows-latest, 18.x), ✅ Integration tests (windows-latest, 16.x), ✅ Integration tests (macOS-latest, 18.x), ✅ Integration tests (macOS-latest, 16.x), ✅ Integration tests (ubuntu-latest, 18.x), ✅ Integration tests (ubuntu-latest, 16.x), ✅ Update test coverage (ubuntu-latest, 16.x), ✅ Lint and static types check (ubuntu-latest, 16.x), ✅ Analyze (javascript), ⏭ dependabot Pull Request URL: #1305
somewhatabstract · Jun 11, 2023 · 14bbc5f · 14bbc5f
1 parent 95d1a29
commit 14bbc5f
Show file tree

Hide file tree

Showing 29 changed files with 868 additions and 528 deletions.
diff --git a/.changeset/lovely-apples-cough.md b/.changeset/lovely-apples-cough.md
@@ -0,0 +1,7 @@
+---
+"checksync": major
+---
+
+- The location of the configuration file is now used as the current working directory, if a configuration file is used. This means that globs are resolved relative to the configuration file, not the current working directory of the process launching checksync, which makes for a more deterministic behavior for
+folks trying to define and use their config files.
+- A `--cwd` argument has been added for specifying the working directory in cases where a configuration file is not used, or the configuration file discover needs to start in a place other than where checksync is invoked. If a configuration file is loaded, the location of that file takes precedence.
diff --git a/.codecov.yml b/.codecov.yml
@@ -5,7 +5,7 @@ coverage:
 
   status:
     project:
-      default: on
+      default: true
     patch:
       default: off
     changes:
@@ -14,6 +14,6 @@ coverage:
 comment:
   layout: "header, reach, diff, flags, files, footer"
   behavior: default
-  require_changes: no
-  require_base: no
-  require_head: yes
+  require_changes: false
+  require_base: false
+  require_head: true
diff --git a/src/__tests__/__snapshots__/cli.test.ts.snap b/src/__tests__/__snapshots__/cli.test.ts.snap
@@ -66,6 +66,21 @@ Where:
                            [1m[33m.checksyncrc[39m[22m
                            [1m[33m.checksyncrc.json[39m[22m
 
+                       Paths within the config file are resolved relative to
+                       the location of the config file.
+
+    [1m[33m--cwd[39m[22m              The current working directory to use when searching
+                       for a configuration file, and resolving relative paths
+                       and globs.
+
+                       The [1m[33m--config[39m[22m path takes precedence over this
+                       argument. If there is no [1m[33m--config[39m[22m argument, this
+                       location is used to find a config file. If a config file
+                       is found, the working directory will then change to
+                       the location of that file, otherwise this argument's
+                       value is used when resolve the remainder of the given
+                       arguments.
+
     [1m[33m--dry-run,-n[39m[22m       Ignored unless supplied with [1m[33m--update-tags[39m[22m.
 
     [1m[33m--help,-h[39m[22m          Outputs this help text.

diff --git a/src/__tests__/__snapshots__/integration.test.ts.snap b/src/__tests__/__snapshots__/integration.test.ts.snap
diff --git a/src/__tests__/check-sync.test.ts b/src/__tests__/check-sync.test.ts
@@ -4,7 +4,7 @@ import * as ProcessCache from "../process-cache";
 import Logger from "../logger";
 
 import checkSync from "../check-sync";
-import ExitCodes from "../exit-codes";
+import {ExitCode} from "../exit-codes";
 
 import {Options} from "../types";
 
@@ -110,16 +110,14 @@ describe("#checkSync", () => {
         const result = await checkSync(options, NullLogger);
 
         // Assert
-        expect(result).toBe(ExitCodes.NO_FILES);
+        expect(result).toBe(ExitCode.NO_FILES);
     });
 
     it("should build a marker cache from the files", async () => {
         // Arrange
         const NullLogger = new Logger();
         jest.spyOn(GetFiles, "default").mockResolvedValue(["filea", "fileb"]);
-        jest.spyOn(ProcessCache, "default").mockResolvedValue(
-            ExitCodes.SUCCESS,
-        );
+        jest.spyOn(ProcessCache, "default").mockResolvedValue(ExitCode.SUCCESS);
         const getMarkersFromFilesSpy = jest
             .spyOn(GetMarkersFromFiles, "default")
             .mockResolvedValue({});
@@ -151,7 +149,7 @@ describe("#checkSync", () => {
         jest.spyOn(GetMarkersFromFiles, "default").mockResolvedValue(fakeCache);
         const ProcessCacheSpy = jest
             .spyOn(ProcessCache, "default")
-            .mockResolvedValue(ExitCodes.SUCCESS);
+            .mockResolvedValue(ExitCode.SUCCESS);
         const options: Options = {
             includeGlobs: ["glob1", "glob2"],
             excludeGlobs: [],
@@ -180,9 +178,7 @@ describe("#checkSync", () => {
         const fakeCache: Record<string, any> = {};
         jest.spyOn(GetFiles, "default").mockResolvedValue(["filea", "fileb"]);
         jest.spyOn(GetMarkersFromFiles, "default").mockResolvedValue(fakeCache);
-        jest.spyOn(ProcessCache, "default").mockResolvedValue(
-            ExitCodes.SUCCESS,
-        );
+        jest.spyOn(ProcessCache, "default").mockResolvedValue(ExitCode.SUCCESS);
 
         // Act
         const result = await checkSync(
@@ -199,6 +195,6 @@ describe("#checkSync", () => {
         );
 
         // Assert
-        expect(result).toBe(ExitCodes.SUCCESS);
+        expect(result).toBe(ExitCode.SUCCESS);
     });
 });
diff --git a/src/__tests__/cli.test.ts b/src/__tests__/cli.test.ts
@@ -4,12 +4,15 @@ import * as minimist from "minimist";
 import fs from "fs";
 import {run} from "../cli";
 import * as CheckSync from "../check-sync";
-import ExitCodes from "../exit-codes";
+import {ExitCode} from "../exit-codes";
 import Logger from "../logger";
 import {version} from "../../package.json";
 import * as DetermineOptions from "../determine-options";
 import defaultOptions from "../default-options";
+import * as Exit from "../exit";
+import * as SetCwd from "../set-cwd";
 
+jest.mock("../set-cwd");
 jest.mock("minimist");
 jest.mock("../logger", () => {
     const realLogger = jest.requireActual("../logger").default;
@@ -45,7 +48,7 @@ describe("#run", () => {
         );
         jest.spyOn(CheckSync, "default").mockResolvedValue(0);
         // @ts-expect-error this is typed to never, but we want to mock it
-        jest.spyOn(process, "exit").mockImplementationOnce(() => {});
+        jest.spyOn(Exit, "default").mockImplementation(() => {});
 
         // Act
         await run(__filename);
@@ -66,8 +69,8 @@ describe("#run", () => {
             } as const;
             jest.spyOn(minimist, "default").mockReturnValue(fakeParsedArgs);
             const exitSpy = jest
-                .spyOn(process, "exit")
-                .mockImplementationOnce(() => {
+                .spyOn(Exit, "default")
+                .mockImplementation(() => {
                     throw new Error("PRETEND PROCESS EXIT!");
                 });
 
@@ -76,7 +79,10 @@ describe("#run", () => {
 
             // Assert
             expect(underTest).toThrowError("PRETEND PROCESS EXIT!");
-            expect(exitSpy).toHaveBeenCalledWith(ExitCodes.SUCCESS);
+            expect(exitSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                ExitCode.SUCCESS,
+            );
         },
     );
 
@@ -86,7 +92,7 @@ describe("#run", () => {
             version: true,
         } as const;
         jest.spyOn(minimist, "default").mockReturnValue(fakeParsedArgs);
-        jest.spyOn(process, "exit").mockImplementationOnce(() => {
+        jest.spyOn(Exit, "default").mockImplementation(() => {
             throw new Error("PRETEND PROCESS EXIT!");
         });
         const logSpy = jest.spyOn(new Logger(null), "log");
@@ -105,7 +111,7 @@ describe("#run", () => {
             help: true,
         } as const;
         jest.spyOn(minimist, "default").mockReturnValue(fakeParsedArgs);
-        jest.spyOn(process, "exit").mockImplementationOnce(() => {
+        jest.spyOn(Exit, "default").mockImplementation(() => {
             throw new Error("PRETEND PROCESS EXIT!");
         });
         const logSpy = jest.spyOn(new Logger(null), "log");
@@ -119,6 +125,28 @@ describe("#run", () => {
         expect(logSpy.mock.calls[0][0]).toMatchSnapshot();
     });
 
+    it("should change the working directory if cwd arg present", async () => {
+        // Arrange
+        const fakeParsedArgs: any = {
+            cwd: "/some/path",
+            verbose: true,
+        } as const;
+        jest.spyOn(minimist, "default").mockReturnValue(fakeParsedArgs);
+        jest.spyOn(DetermineOptions, "default").mockResolvedValue(
+            defaultOptions,
+        );
+        jest.spyOn(CheckSync, "default").mockResolvedValue(0);
+        // @ts-expect-error this is typed to never, but we want to mock it
+        jest.spyOn(Exit, "default").mockImplementation(() => {});
+        const setCwdSpy = jest.spyOn(SetCwd, "default");
+
+        // Act
+        await run(__filename);
+
+        // Assert
+        expect(setCwdSpy).toHaveBeenCalledWith(expect.anything(), "/some/path");
+    });
+
     it("should pass arguments to determineOptions", async () => {
         // Arrange
         const fakeParsedArgs: any = {
@@ -130,7 +158,7 @@ describe("#run", () => {
             .mockResolvedValue(defaultOptions);
         jest.spyOn(CheckSync, "default").mockResolvedValue(0);
         // @ts-expect-error this is typed to never, but we want to mock it
-        jest.spyOn(process, "exit").mockImplementationOnce(() => {});
+        jest.spyOn(Exit, "default").mockImplementation(() => {});
 
         // Act
         await run(__filename);
@@ -158,7 +186,7 @@ describe("#run", () => {
             .spyOn(CheckSync, "default")
             .mockResolvedValue(0);
         // @ts-expect-error this is typed to never, but we want to mock it
-        jest.spyOn(process, "exit").mockImplementationOnce(() => {});
+        jest.spyOn(Exit, "default").mockImplementation(() => {});
 
         // Act
         await run(__filename);
@@ -181,7 +209,7 @@ describe("#run", () => {
         jest.spyOn(minimist, "default").mockReturnValue(fakeParsedArgs);
         jest.spyOn(fs, "existsSync").mockReturnValueOnce(false);
         // @ts-expect-error this is typed to never, but we want to mock it
-        jest.spyOn(process, "exit").mockImplementationOnce(() => {});
+        jest.spyOn(Exit, "default").mockImplementation(() => {});
         const setVerboseSpy = jest.spyOn(new Logger(null), "setVerbose");
 
         // Act
@@ -198,15 +226,18 @@ describe("#run", () => {
         );
         jest.spyOn(minimist, "default").mockReturnValue({} as any);
         const exitSpy = jest
-            .spyOn(process, "exit")
+            .spyOn(Exit, "default")
             // @ts-expect-error this is typed to never, but we want to mock it
-            .mockImplementationOnce(() => {});
+            .mockImplementation(() => {});
 
         // Act
         await run(__filename);
 
         // Assert
-        expect(exitSpy).toHaveBeenCalledWith(ExitCodes.BAD_CONFIG);
+        expect(exitSpy).toHaveBeenCalledWith(
+            expect.anything(),
+            ExitCode.BAD_CONFIG,
+        );
     });
 
     it("should exit process with the exit code from checkSync", async () => {
@@ -217,15 +248,15 @@ describe("#run", () => {
         );
         jest.spyOn(minimist, "default").mockReturnValue({} as any);
         const exitSpy = jest
-            .spyOn(process, "exit")
+            .spyOn(Exit, "default")
             // @ts-expect-error this is typed to never, but we want to mock it
-            .mockImplementationOnce(() => {});
+            .mockImplementation(() => {});
 
         // Act
         await run(__filename);
 
         // Assert
-        expect(exitSpy).toHaveBeenCalledWith(42);
+        expect(exitSpy).toHaveBeenCalledWith(expect.anything(), 42);
     });
 
     it("should log error on rejection of checkSync method", async () => {
@@ -238,7 +269,7 @@ describe("#run", () => {
         );
         jest.spyOn(minimist, "default").mockReturnValue({} as any);
         // @ts-expect-error this is typed to never, but we want to mock it
-        jest.spyOn(process, "exit").mockImplementation(() => {});
+        jest.spyOn(Exit, "default").mockImplementation(() => {});
         const logSpy = jest.spyOn(new Logger(null), "error");
 
         // Act
@@ -260,15 +291,18 @@ describe("#run", () => {
         );
         jest.spyOn(minimist, "default").mockReturnValue({} as any);
         const exitSpy = jest
-            .spyOn(process, "exit")
+            .spyOn(Exit, "default")
             // @ts-expect-error this is typed to never, but we want to mock it
             .mockImplementation(() => {});
 
         // Act
         await run(__filename);
 
         // Assert
-        expect(exitSpy).toHaveBeenCalledWith(ExitCodes.CATASTROPHIC);
+        expect(exitSpy).toHaveBeenCalledWith(
+            expect.anything(),
+            ExitCode.CATASTROPHIC,
+        );
     });
 
     describe("unknown arg handling", () => {
@@ -279,7 +313,7 @@ describe("#run", () => {
                 defaultOptions,
             );
             // @ts-expect-error this is typed to never, but we want to mock it
-            jest.spyOn(process, "exit").mockImplementationOnce(() => {});
+            jest.spyOn(Exit, "default").mockImplementation(() => {});
             const minimistSpy = jest
                 .spyOn(minimist, "default")
                 .mockReturnValue({} as any);
@@ -300,7 +334,7 @@ describe("#run", () => {
                 defaultOptions,
             );
             // @ts-expect-error this is typed to never, but we want to mock it
-            jest.spyOn(process, "exit").mockImplementationOnce(() => {});
+            jest.spyOn(Exit, "default").mockImplementation(() => {});
             const minimistSpy = jest
                 .spyOn(minimist, "default")
                 .mockReturnValue({} as any);
@@ -321,7 +355,7 @@ describe("#run", () => {
                 defaultOptions,
             );
             // @ts-expect-error this is typed to never, but we want to mock it
-            jest.spyOn(process, "exit").mockImplementationOnce(() => {});
+            jest.spyOn(Exit, "default").mockImplementation(() => {});
             const minimistSpy = jest
                 .spyOn(minimist, "default")
                 .mockReturnValue({} as any);
@@ -342,7 +376,7 @@ describe("#run", () => {
                 defaultOptions,
             );
             // @ts-expect-error this is typed to never, but we want to mock it
-            jest.spyOn(process, "exit").mockImplementationOnce(() => {});
+            jest.spyOn(Exit, "default").mockImplementation(() => {});
             const minimistSpy = jest
                 .spyOn(minimist, "default")
                 .mockReturnValue({} as any);
@@ -366,7 +400,7 @@ describe("#run", () => {
                 defaultOptions,
             );
             const exitSpy = jest
-                .spyOn(process, "exit")
+                .spyOn(Exit, "default")
                 // @ts-expect-error this is typed to never, but we want to mock it
                 .mockImplementation(() => {});
             const minimistSpy = jest
@@ -379,7 +413,10 @@ describe("#run", () => {
             unknownHandler?.("--imadethisup");
 
             // Assert
-            expect(exitSpy).toHaveBeenCalledWith(ExitCodes.UNKNOWN_ARGS);
+            expect(exitSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                ExitCode.UNKNOWN_ARGS,
+            );
         });
 
         it("should report unknown arguments starting with -", async () => {
@@ -389,7 +426,7 @@ describe("#run", () => {
                 defaultOptions,
             );
             // @ts-expect-error this is typed to never, but we want to mock it
-            jest.spyOn(process, "exit").mockImplementation(() => {});
+            jest.spyOn(Exit, "default").mockImplementation(() => {});
             const minimistSpy = jest
                 .spyOn(minimist, "default")
                 .mockReturnValue({} as any);
@@ -413,7 +450,7 @@ describe("#run", () => {
                 defaultOptions,
             );
             // @ts-expect-error this is typed to never, but we want to mock it
-            jest.spyOn(process, "exit").mockImplementation(() => {});
+            jest.spyOn(Exit, "default").mockImplementation(() => {});
             const minimistSpy = jest
                 .spyOn(minimist, "default")
                 .mockReturnValue({} as any);