simple-git-hooks.test.js

const fs = require("fs");
const path = require("path");
const { execSync } = require("child_process");

const isEqual = require("lodash.isequal");

const simpleGitHooks = require("./simple-git-hooks");
const { version: packageVersion } = require("./package.json");

// Util functions:





describe("Simple Git Hooks tests", () => {
  /**
   * This section of tests is used to test how simple util functions perform
   * If you are adding a new util function, you should create unit test suite (describe) for it
   */
  describe('Unit tests', () => {
    describe("getProjectRootDirectory", () => {
      it("returns correct dir in typical case:", () => {
        expect(
            simpleGitHooks.getProjectRootDirectoryFromNodeModules(
                "var/my-project/node_modules/simple-git-hooks"
            )
        ).toBe("var/my-project");
      });

      it("returns correct dir when used with windows delimiters:", () => {
        expect(
            simpleGitHooks.getProjectRootDirectoryFromNodeModules(
                "user\\allProjects\\project\\node_modules\\simple-git-hooks"
            )
        ).toBe("user/allProjects/project");
      });

      it("falls back to undefined when we are not in node_modules:", () => {
        expect(
            simpleGitHooks.getProjectRootDirectoryFromNodeModules(
                "var/my-project/simple-git-hooks"
            )
        ).toBe(undefined);
      });

      it("return correct dir when installed using pnpm:", () => {
        expect(
            simpleGitHooks.getProjectRootDirectoryFromNodeModules(
                `var/my-project/node_modules/.pnpm/simple-git-hooks@${packageVersion}`
            )
        ).toBe("var/my-project");
        expect(
            simpleGitHooks.getProjectRootDirectoryFromNodeModules(
                `var/my-project/node_modules/.pnpm/simple-git-hooks@${packageVersion}/node_modules/simple-git-hooks`
            )
        ).toBe("var/my-project");
      });

      it("return correct dir when installed using yarn3 nodeLinker pnpm:", () => {
        expect(
            simpleGitHooks.getProjectRootDirectoryFromNodeModules(
                `var/my-project/node_modules/.store/simple-git-hooks@${packageVersion}/node_modules/simple-git-hooks`
            )
        ).toBe("var/my-project");
      });
      
      it("return correct dir when installed using deno:", () => {
        expect(
            simpleGitHooks.getProjectRootDirectoryFromNodeModules(
                `var/my-project/node_modules/.deno/simple-git-hooks@${packageVersion}/node_modules/simple-git-hooks`
            )
        ).toBe("var/my-project");
      });

      it("return correct dir when installed using bun with --linker=isolated", () => {
        expect(
            simpleGitHooks.getProjectRootDirectoryFromNodeModules(
                `var/my-project/node_modules/.bun/simple-git-hooks@${packageVersion}/node_modules/simple-git-hooks`
            )
        ).toBe('var/my-project');
      })
    });

    describe("getProjectRootDirectory", () => {
      // __dirname is this repo's root, which contains a package.json — a stand-in
      // for a real INIT_CWD (the directory a package manager runs postinstall from).
      const realProjectRoot = __dirname;

      // The test runner (npm/yarn/pnpm test) sets INIT_CWD itself, so clear it to
      // keep each case hermetic; the value is passed explicitly where it matters.
      let originalInitCwd;
      beforeEach(() => {
        originalInitCwd = process.env.INIT_CWD;
        delete process.env.INIT_CWD;
      });
      afterEach(() => {
        if (originalInitCwd === undefined) {
          delete process.env.INIT_CWD;
        } else {
          process.env.INIT_CWD = originalInitCwd;
        }
      });

      it("prefers INIT_CWD when it points at a directory with a package.json", () => {
        // cwd is the package's physical location in an isolated store whose marker
        // getProjectRootDirectoryFromNodeModules does not recognize — the layout
        // that used to crash. INIT_CWD resolves the root regardless of the layout.
        expect(
            simpleGitHooks.getProjectRootDirectory(
                realProjectRoot,
                "/var/my-project/node_modules/.some-store/simple-git-hooks@2.13.1/node_modules/simple-git-hooks"
            )
        ).toBe(realProjectRoot);
      });

      it("falls back to the node_modules heuristic when INIT_CWD is unset", () => {
        expect(
            simpleGitHooks.getProjectRootDirectory(
                undefined,
                `/var/my-project/node_modules/.pnpm/simple-git-hooks@${packageVersion}/node_modules/simple-git-hooks`
            )
        ).toBe("/var/my-project");
      });

      it("ignores INIT_CWD when it does not point at a directory with a package.json", () => {
        expect(
            simpleGitHooks.getProjectRootDirectory(
                path.join(realProjectRoot, "this-directory-does-not-exist"),
                "/var/my-project/node_modules/simple-git-hooks"
            )
        ).toBe("/var/my-project");
      });

      it("falls back to cwd when INIT_CWD is unset and cwd is not inside node_modules", () => {
        expect(
            simpleGitHooks.getProjectRootDirectory(undefined, "/var/my-project")
        ).toBe("/var/my-project");
      });

      it("reads process.env.INIT_CWD when called with no arguments", () => {
        process.env.INIT_CWD = realProjectRoot;
        expect(simpleGitHooks.getProjectRootDirectory()).toBe(realProjectRoot);
      });
    });

    describe("getGitProjectRoot", () => {
      const gitProjectRoot = path.normalize(path.join(__dirname, ".git"));
      const currentPath = path.normalize(path.join(__dirname));
      const currentFilePath = path.normalize(path.join(__filename));

      it("works from .git directory itself", () => {
        expect(simpleGitHooks.getGitProjectRoot(gitProjectRoot)).toBe(gitProjectRoot);
      });

      it("works from any directory", () => {
        expect(simpleGitHooks.getGitProjectRoot(currentPath)).toBe(gitProjectRoot);
      });

      it("works from any file", () => {
        expect(simpleGitHooks.getGitProjectRoot(currentFilePath)).toBe(gitProjectRoot);
      });
    });

    describe("checkSimpleGitHooksInDependencies", () => {
      const PROJECT_WITH_SIMPLE_GIT_HOOKS_IN_DEPS = path.normalize(
          path.join(process.cwd(), "_tests", "project_with_simple_git_hooks_in_deps")
      );
      const PROJECT_WITH_SIMPLE_GIT_HOOKS_IN_DEV_DEPS = path.normalize(
          path.join(
              process.cwd(), "_tests", "project_with_simple_git_hooks_in_dev_deps"
          )
      );
      const PROJECT_WITHOUT_SIMPLE_GIT_HOOKS = path.normalize(
          path.join(process.cwd(), "_tests", "project_without_simple_git_hooks")
      );
      it("returns true if simple-git-hooks really in deps", () => {
        expect(
            simpleGitHooks.checkSimpleGitHooksInDependencies(PROJECT_WITH_SIMPLE_GIT_HOOKS_IN_DEPS)
        ).toBe(true);
      });

      it("returns true if simple-git-hooks really in devDeps", () => {
        expect(
            simpleGitHooks.checkSimpleGitHooksInDependencies(PROJECT_WITH_SIMPLE_GIT_HOOKS_IN_DEV_DEPS)
        ).toBe(true);
      });

      it("returns false if simple-git-hooks isn`t in deps", () => {
        expect(
            simpleGitHooks.checkSimpleGitHooksInDependencies(PROJECT_WITHOUT_SIMPLE_GIT_HOOKS)
        ).toBe(false);
      });

      it("returns false (does not throw) when package.json does not exist", () => {
        // A directory that exists but has no package.json (the postinstall scenario in #112)
        const dirWithoutPackageJson = fs.mkdtempSync(
            path.join(process.cwd(), "_tests", "no_package_json_")
        );
        try {
          expect(
              simpleGitHooks.checkSimpleGitHooksInDependencies(dirWithoutPackageJson)
          ).toBe(false);
        } finally {
          fs.rmSync(dirWithoutPackageJson, { recursive: true, force: true });
        }
      });
    });
  });

  /**
   * This section of tests should test end 2 end use scenarios.
   * If you are adding a new feature, you should create an e2e test suite (describe) for it
   */
  describe('E2E tests', () => {

    const TEST_SCRIPT = `${simpleGitHooks.PREPEND_SCRIPT}exit 1`;
    const COMMON_GIT_HOOKS = { "pre-commit": TEST_SCRIPT, "pre-push": TEST_SCRIPT };

    // To test this package, we often need to create and manage files.
    // Best to use real file system and real files under _tests folder
    const testsFolder = path.normalize(path.join(process.cwd(), "_tests"));

    // Configuration in Package.json
    const PROJECT_WITH_CONF_IN_PACKAGE_JSON = path.normalize(
        path.join(testsFolder, "project_with_configuration_in_package_json")
    );

    // Configuration in .js file
    const PROJECT_WITH_CONF_IN_SEPARATE_JS = path.normalize(
        path.join(testsFolder, "project_with_configuration_in_separate_js")
    );
    const PROJECT_WITH_CONF_IN_SEPARATE_JS_ALT = path.normalize(
        path.join(testsFolder, "project_with_configuration_in_alternative_separate_js")
    );

    // Configuration in .cjs file
    const PROJECT_WITH_CONF_IN_SEPARATE_CJS = path.normalize(
        path.join(testsFolder, "project_with_configuration_in_separate_cjs")
    );
    const PROJECT_WITH_CONF_IN_SEPARATE_CJS_ALT = path.normalize(
        path.join(testsFolder, "project_with_configuration_in_alternative_separate_cjs")
    );

    // Configuration in .mjs file
    const PROJECT_WITH_CONF_IN_SEPARATE_MJS = path.normalize(
        path.join(testsFolder, "project_with_configuration_in_separate_mjs")
    );
    const PROJECT_WITH_CONF_IN_SEPARATE_MJS_ALT = path.normalize(
        path.join(testsFolder, "project_with_configuration_in_alternative_separate_mjs")
    );

    // Configuration in .json file
    const PROJECT_WITH_CONF_IN_SEPARATE_JSON = path.normalize(
        path.join(testsFolder, "project_with_configuration_in_separate_json")
    );
    const PROJECT_WITH_CONF_IN_SEPARATE_JSON_ALT = path.normalize(
        path.join(testsFolder, "project_with_configuration_in_alternative_separate_json")
    );

    // Other correct configurations
    const PROJECT_WITH_UNUSED_CONF_IN_PACKAGE_JSON = path.normalize(
        path.join(testsFolder, "project_with_unused_configuration_in_package_json")
    );
    const PROJECT_WITH_CUSTOM_CONF = path.normalize(
        path.join(testsFolder, "project_with_custom_configuration")
    );

    // Incorrect configurations
    const PROJECT_WITH_BAD_CONF_IN_PACKAGE_JSON_ = path.normalize(
        path.join(testsFolder, "project_with_incorrect_configuration_in_package_json")
    );
    const PROJECT_WO_CONF = path.normalize(
        path.join(testsFolder, "project_without_configuration")
    );

    /**
     * Creates .git/hooks dir from root
     * @param {string} root
     */
    function createGitHooksFolder(root) {
      if (fs.existsSync(root + "/.git")) {
        return;
      }
      fs.mkdirSync(root + "/.git");
      fs.mkdirSync(root + "/.git/hooks");
    }

    /**
     * Removes .git directory from root
     * @param {string} root
     */
    function removeGitHooksFolder(root) {
      if (fs.existsSync(root + "/.git")) {
        fs.rmdirSync(root + "/.git", { recursive: true });
      }
    }

    /**
     * Returns all installed git hooks
     * @return { {string: string} }
     */
    function getInstalledGitHooks(hooksDir) {
      const result = {};

      const hooks = fs.readdirSync(hooksDir);

      for (let hook of hooks) {
        result[hook] = fs
            .readFileSync(path.normalize(path.join(hooksDir, hook)))
            .toString();
      }

      return result;
    }

    describe('Configuration tests', function () {
      describe("Valid configurations", () => {
        it("creates git hooks if configuration is correct from .simple-git-hooks.js", async () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_SEPARATE_JS_ALT);

          await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_CONF_IN_SEPARATE_JS_ALT);
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(
                      PROJECT_WITH_CONF_IN_SEPARATE_JS_ALT,
                      ".git",
                      "hooks"
                  )
              )
          );
          expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
        });

        it("creates git hooks if configuration is correct from .simple-git-hooks.cjs", async () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_SEPARATE_CJS_ALT);

          await simpleGitHooks.setHooksFromConfig(
              PROJECT_WITH_CONF_IN_SEPARATE_CJS_ALT
          );
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(
                      PROJECT_WITH_CONF_IN_SEPARATE_CJS_ALT,
                      ".git",
                      "hooks"
                  )
              )
          );
          expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
        });

        it("creates git hooks if configuration is correct from simple-git-hooks.cjs", async () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_SEPARATE_CJS);

          await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_CONF_IN_SEPARATE_CJS);
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(PROJECT_WITH_CONF_IN_SEPARATE_CJS, ".git", "hooks")
              )
          );
          expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
        });

        it("creates git hooks if configuration is correct from .simple-git-hooks.mjs", async () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_SEPARATE_MJS_ALT);

          await simpleGitHooks.setHooksFromConfig(
            PROJECT_WITH_CONF_IN_SEPARATE_MJS_ALT
          );
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(
                    PROJECT_WITH_CONF_IN_SEPARATE_MJS_ALT,
                      ".git",
                      "hooks"
                  )
              )
          );
          expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
        });

        it("creates git hooks if configuration is correct from simple-git-hooks.mjs", async () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_SEPARATE_MJS);

          await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_CONF_IN_SEPARATE_MJS);
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(PROJECT_WITH_CONF_IN_SEPARATE_MJS, ".git", "hooks")
              )
          );
          expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
        });

        it("creates git hooks if configuration is correct from simple-git-hooks.js", async () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_SEPARATE_JS);

          await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_CONF_IN_SEPARATE_JS);
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(PROJECT_WITH_CONF_IN_SEPARATE_JS, ".git", "hooks")
              )
          );
          expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
        });

        it("creates git hooks if configuration is correct from .simple-git-hooks.json", async () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_SEPARATE_JSON_ALT);

          await simpleGitHooks.setHooksFromConfig(
              PROJECT_WITH_CONF_IN_SEPARATE_JSON_ALT
          );
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(
                      PROJECT_WITH_CONF_IN_SEPARATE_JSON_ALT,
                      ".git",
                      "hooks"
                  )
              )
          );
          expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
        });

        it("creates git hooks if configuration is correct from simple-git-hooks.json", async () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_SEPARATE_JSON);

          await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_CONF_IN_SEPARATE_JSON);
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(PROJECT_WITH_CONF_IN_SEPARATE_JSON, ".git", "hooks")
              )
          );
          expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
        });

        it("creates git hooks if configuration is correct from package.json", async () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_PACKAGE_JSON);

          await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(PROJECT_WITH_CONF_IN_PACKAGE_JSON, ".git", "hooks")
              )
          );
          expect(isEqual(installedHooks, { "pre-commit": TEST_SCRIPT })).toBe(true);
        });
      });

      describe("Invalid configurations", () => {
        it("fails to create git hooks if configuration contains bad git hooks", async () => {
          createGitHooksFolder(PROJECT_WITH_BAD_CONF_IN_PACKAGE_JSON_);

          await expect(
            simpleGitHooks.setHooksFromConfig(PROJECT_WITH_BAD_CONF_IN_PACKAGE_JSON_)
          ).rejects.toMatch(
              "[ERROR] Config was not in correct format. Please check git hooks or options name"
          );
        });

        it("fails to create git hooks if not configured", async () => {
          createGitHooksFolder(PROJECT_WO_CONF);

          await expect(() => simpleGitHooks.setHooksFromConfig(PROJECT_WO_CONF)).rejects.toMatch(
              "[ERROR] Config was not found! Please add `.simple-git-hooks.cjs` or `.simple-git-hooks.js` or `.simple-git-hooks.mjs` or `simple-git-hooks.cjs` or `simple-git-hooks.js` or `simple-git-hooks.mjs` or `.simple-git-hooks.json` or `simple-git-hooks.json` or `simple-git-hooks` entry in package.json."
          );
        });
      });
    });

    describe("Remove hooks tests", () => {
      it("removes git hooks", async () => {
        createGitHooksFolder(PROJECT_WITH_CONF_IN_PACKAGE_JSON);

        await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_CONF_IN_PACKAGE_JSON);

        let installedHooks = getInstalledGitHooks(
            path.normalize(
                path.join(PROJECT_WITH_CONF_IN_PACKAGE_JSON, ".git", "hooks")
            )
        );
        expect(isEqual(installedHooks, { "pre-commit": TEST_SCRIPT })).toBe(true);

        await simpleGitHooks.removeHooks(PROJECT_WITH_CONF_IN_PACKAGE_JSON);

        installedHooks = getInstalledGitHooks(
            path.normalize(
                path.join(PROJECT_WITH_CONF_IN_PACKAGE_JSON, ".git", "hooks")
            )
        );
        expect(isEqual(installedHooks, {})).toBe(true);
      });

      it("creates git hooks and removes unused git hooks", async () => {
        createGitHooksFolder(PROJECT_WITH_CONF_IN_PACKAGE_JSON);

        const installedHooksDir = path.normalize(
            path.join(PROJECT_WITH_CONF_IN_PACKAGE_JSON, ".git", "hooks")
        );

        fs.writeFileSync(
            path.resolve(installedHooksDir, "pre-push"),
            "# do nothing"
        );

        let installedHooks = getInstalledGitHooks(installedHooksDir);
        expect(isEqual(installedHooks, { "pre-push": "# do nothing" })).toBe(true);

        await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_CONF_IN_PACKAGE_JSON);

        installedHooks = getInstalledGitHooks(installedHooksDir);
        expect(isEqual(installedHooks, { "pre-commit": TEST_SCRIPT })).toBe(true);
      });

      it("creates git hooks and removes unused but preserves specific git hooks", async () => {
        createGitHooksFolder(PROJECT_WITH_UNUSED_CONF_IN_PACKAGE_JSON);

        const installedHooksDir = path.normalize(
            path.join(
                PROJECT_WITH_UNUSED_CONF_IN_PACKAGE_JSON,
                ".git",
                "hooks"
            )
        );

        fs.writeFileSync(
            path.resolve(installedHooksDir, "commit-msg"),
            "# do nothing"
        );
        fs.writeFileSync(
            path.resolve(installedHooksDir, "pre-push"),
            "# do nothing"
        );

        let installedHooks = getInstalledGitHooks(installedHooksDir);
        expect(
            isEqual(installedHooks, {
              "commit-msg": "# do nothing",
              "pre-push": "# do nothing",
            })
        ).toBe(true);

        await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_UNUSED_CONF_IN_PACKAGE_JSON);

        installedHooks = getInstalledGitHooks(installedHooksDir);
        expect(
            isEqual(installedHooks, {
              "commit-msg": "# do nothing",
              "pre-commit": TEST_SCRIPT,
            })
        ).toBe(true);
      });

      it("creates git hooks and removes hooks which are not in preserveUnused", async () => {
        createGitHooksFolder(PROJECT_WITH_UNUSED_CONF_IN_PACKAGE_JSON);

        const installedHooksDir = path.normalize(
          path.join(
              PROJECT_WITH_UNUSED_CONF_IN_PACKAGE_JSON,
              ".git",
              "hooks"
          )
        );

        fs.writeFileSync(
            path.resolve(installedHooksDir, "commit-msg"),
            "# do nothing"
        );

        let installedHooks = getInstalledGitHooks(installedHooksDir);

        expect(isEqual(installedHooks, { "commit-msg": "# do nothing" })).toBe(true);

        await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_UNUSED_CONF_IN_PACKAGE_JSON);

        installedHooks = getInstalledGitHooks(installedHooksDir);
        expect(isEqual(installedHooks, { "pre-commit": TEST_SCRIPT, "commit-msg": "# do nothing" })).toBe(true);

        await simpleGitHooks.removeHooks(PROJECT_WITH_UNUSED_CONF_IN_PACKAGE_JSON);

        installedHooks = getInstalledGitHooks(installedHooksDir);
        expect(isEqual(installedHooks, { "commit-msg": "# do nothing" })).toBe(true);
      });
    });

    describe("Custom core.hooksPath", () => {
      beforeAll(() => {
        execSync('git config core.hooksPath .husky');
      });

      afterAll(() => {
        execSync('git config --unset core.hooksPath');
      });

      const TEST_HUSKY_PROJECT = PROJECT_WITH_CONF_IN_SEPARATE_JS_ALT;

      it("creates git hooks in .husky if core.hooksPath is set to .husky", async () => {
        const huskyDir = path.join(TEST_HUSKY_PROJECT, ".husky");
    
        if (!fs.existsSync(huskyDir)) {
          fs.mkdirSync(huskyDir);
        }

        await simpleGitHooks.setHooksFromConfig(TEST_HUSKY_PROJECT);

        const installedHooks = getInstalledGitHooks(huskyDir);
        expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
      })

      it("remove git hooks in .husky if core.hooksPath is set to .husky", async () => {
        await simpleGitHooks.removeHooks(TEST_HUSKY_PROJECT);
        const huskyDir = path.join(TEST_HUSKY_PROJECT, ".husky");
        const installedHooks = getInstalledGitHooks(huskyDir);
        expect(isEqual(installedHooks, {})).toBe(true);
      })
    })

    describe("Git worktree support", () => {
      // A worktree needs a real git repository, so we create one under _tests
      const WORKTREE_TEST_DIR = path.join(testsFolder, "tmp_worktree_project");
      const MAIN_REPO = path.join(WORKTREE_TEST_DIR, "main");
      const LINKED_WORKTREE = path.join(WORKTREE_TEST_DIR, "linked");
      // In a worktree, hooks live in the main repository's .git/hooks
      const SHARED_HOOKS_DIR = path.join(MAIN_REPO, ".git", "hooks");

      // git writes a relative gitdir into the worktree .git file only since 2.48
      const supportsRelativePaths = execSync("git worktree add -h 2>&1 || true")
          .toString()
          .includes("relative-paths");

      /**
       * Creates a main repository with one linked worktree
       * @param {string} worktreeAddFlags - extra flags for git worktree add
       */
      function createRepoWithWorktree(worktreeAddFlags = "") {
        fs.rmSync(WORKTREE_TEST_DIR, { recursive: true, force: true });
        fs.mkdirSync(MAIN_REPO, { recursive: true });

        const git = (cmd) => execSync(`git ${cmd}`, { cwd: MAIN_REPO, stdio: "ignore" });

        git("init");
        git("config user.email test@test.test");
        git("config user.name test");
        fs.writeFileSync(
            path.join(MAIN_REPO, "package.json"),
            JSON.stringify({
              name: "worktree-project",
              "simple-git-hooks": { "pre-commit": "exit 1", "pre-push": "exit 1" }
            })
        );
        git("add -A");
        git('commit -m init');
        git(`worktree add ${worktreeAddFlags} ${LINKED_WORKTREE} -b linked-branch`);

        // git init fills .git/hooks with *.sample files, drop them so that
        // the directory only contains what simple-git-hooks puts there
        for (const sample of fs.readdirSync(SHARED_HOOKS_DIR)) {
          fs.rmSync(path.join(SHARED_HOOKS_DIR, sample));
        }
      }

      beforeEach(() => {
        createRepoWithWorktree();
      });

      afterEach(() => {
        fs.rmSync(WORKTREE_TEST_DIR, { recursive: true, force: true });
      });

      it("creates git hooks in the main repository when run from a worktree", async () => {
        await simpleGitHooks.setHooksFromConfig(LINKED_WORKTREE);

        const installedHooks = getInstalledGitHooks(SHARED_HOOKS_DIR);
        expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
      });

      // The test process runs from the package root, so this also covers the case
      // where the current working directory is not the worktree itself
      (supportsRelativePaths ? it : it.skip)(
          "creates git hooks in the main repository when the worktree uses relative paths",
          async () => {
            createRepoWithWorktree("--relative-paths");

            await simpleGitHooks.setHooksFromConfig(LINKED_WORKTREE);

            const installedHooks = getInstalledGitHooks(SHARED_HOOKS_DIR);
            expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
          }
      );

      it("removes git hooks from the main repository when run from a worktree", async () => {
        await simpleGitHooks.setHooksFromConfig(LINKED_WORKTREE);
        await simpleGitHooks.removeHooks(LINKED_WORKTREE);

        const installedHooks = getInstalledGitHooks(SHARED_HOOKS_DIR);
        expect(isEqual(installedHooks, {})).toBe(true);
      });
    });

    describe("CLI tests", () => {
      const testCases = [
        ["npx", "simple-git-hooks", "./git-hooks.js"],
        ["node", require.resolve(`./cli`), "./git-hooks.js"],
        [
          "node",
          require.resolve(`./cli`),
          require.resolve(`${PROJECT_WITH_CUSTOM_CONF}/git-hooks.js`),
        ],
      ];

      testCases.forEach((args) => {
        it(`creates git hooks and removes unused but preserves specific git hooks for command: ${args.join(
            " "
        )}`, async () => {
          createGitHooksFolder(PROJECT_WITH_CUSTOM_CONF);

          await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_CUSTOM_CONF, args);
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(PROJECT_WITH_CUSTOM_CONF, ".git", "hooks")
              )
          );
          expect(JSON.stringify(installedHooks)).toBe(JSON.stringify(COMMON_GIT_HOOKS));
          expect(isEqual(installedHooks, COMMON_GIT_HOOKS)).toBe(true);
        });
      });

      describe("SKIP_INSTALL_SIMPLE_GIT_HOOKS", () => {
        afterEach(() => {
            removeGitHooksFolder(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
        });

        it("does not create git hooks when SKIP_INSTALL_SIMPLE_GIT_HOOKS is set to 1", () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
          execSync(`node ${require.resolve("./cli")}`, {
            cwd: PROJECT_WITH_CONF_IN_PACKAGE_JSON,
            env: {
                ...process.env,
                SKIP_INSTALL_SIMPLE_GIT_HOOKS: "1",
            },
          });
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(PROJECT_WITH_CONF_IN_PACKAGE_JSON, ".git", "hooks")
              )
          );
          expect(installedHooks).toEqual({});
        });

        it("creates git hooks when SKIP_INSTALL_SIMPLE_GIT_HOOKS is set to 0", () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
          execSync(`node ${require.resolve("./cli")}`, {
            cwd: PROJECT_WITH_CONF_IN_PACKAGE_JSON,
            env: {
                ...process.env,
                SKIP_INSTALL_SIMPLE_GIT_HOOKS: "0",
            },
          });
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(PROJECT_WITH_CONF_IN_PACKAGE_JSON, ".git", "hooks")
              )
          );
          expect(installedHooks).toEqual({ "pre-commit": TEST_SCRIPT });
        });

        it("creates git hooks when SKIP_INSTALL_SIMPLE_GIT_HOOKS is not set", () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
          execSync(`node ${require.resolve("./cli")}`, {
            cwd: PROJECT_WITH_CONF_IN_PACKAGE_JSON,
          });
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(PROJECT_WITH_CONF_IN_PACKAGE_JSON, ".git", "hooks")
              )
          );
          expect(installedHooks).toEqual({ "pre-commit": TEST_SCRIPT });
        });

        it("does not create git hooks during postinstall hook when SKIP_INSTALL_SIMPLE_GIT_HOOKS is set to 1", () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
          execSync(`node ${require.resolve("./postinstall")}`, {
            cwd: PROJECT_WITH_CONF_IN_PACKAGE_JSON,
            env: {
                ...process.env,
                SKIP_INSTALL_SIMPLE_GIT_HOOKS: "1",
            },
          });
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(PROJECT_WITH_CONF_IN_PACKAGE_JSON, ".git", "hooks")
              )
          );
          expect(installedHooks).toEqual({});
        });

        it("creates git hooks during postinstall when SKIP_INSTALL_SIMPLE_GIT_HOOKS is set to 0", () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
          execSync(`node ${require.resolve("./postinstall")}`, {
            cwd: PROJECT_WITH_CONF_IN_PACKAGE_JSON,
            env: {
                ...process.env,
                SKIP_INSTALL_SIMPLE_GIT_HOOKS: "0",
                INIT_CWD: undefined,
            },
          });
          const installedHooks = getInstalledGitHooks(
              path.normalize(
                  path.join(PROJECT_WITH_CONF_IN_PACKAGE_JSON, ".git", "hooks")
              )
          );
          expect(installedHooks).toEqual({ "pre-commit": TEST_SCRIPT });
        });
      });

      describe('should silently succeed if all hooks are already installed', () => {
        it('silent success by default', async () => {
          createGitHooksFolder(PROJECT_WITH_CONF_IN_SEPARATE_JSON);

          const output1 = execSync(`node ${require.resolve("./cli")}`, { cwd: PROJECT_WITH_CONF_IN_SEPARATE_JSON, encoding: 'utf8' });
          expect(output1).toMatch(/\[INFO\] Successfully set all git hooks/);
          expect(output1).toMatch(/\[INFO\] Successfully set the pre-commit with command: exit 1/);

          const output2 = execSync(`node ${require.resolve("./cli")}`, { cwd: PROJECT_WITH_CONF_IN_SEPARATE_JSON, encoding: 'utf8' }).trim();
          expect(output2).toBe('');
        })
      });
    });

    describe("ENV vars features tests", () => {
      const GIT_USER_NAME = "github-actions";
      const GIT_USER_EMAIL = "github-actions@github.com";

      const initializeGitRepository = (path) => {
        execSync(
            `git init \
            && git config user.name ${GIT_USER_NAME} \
            && git config user.email ${GIT_USER_EMAIL}`,
            { cwd: path }
        );
      };

      const tryToPerformTestCommit = (path, env = process.env) => {
        try {
          execSync(
              'git add . && git commit --allow-empty -m "Test commit" && git commit --allow-empty -am "Change commit msg"',
              { cwd: path, env: env, }
          );
          return true;
        } catch (e) {
          return false;
        }
      };

      const expectCommitToSucceed = (path) => {
        expect(tryToPerformTestCommit(path)).toBe(true);
      };

      const expectCommitToFail = (path) => {
        expect(tryToPerformTestCommit(path)).toBe(false);
      };

      beforeEach(async () => {
        initializeGitRepository(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
        createGitHooksFolder(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
        await simpleGitHooks.setHooksFromConfig(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
      });

      describe("SKIP_SIMPLE_GIT_HOOKS", () => {
        afterEach(() => {
          delete process.env.SKIP_SIMPLE_GIT_HOOKS;
        });

        it('commits successfully when SKIP_SIMPLE_GIT_HOOKS is set to "1"', () => {
          process.env.SKIP_SIMPLE_GIT_HOOKS = "1";
          expectCommitToSucceed(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
        });

        it("fails to commit when SKIP_SIMPLE_GIT_HOOKS is not set", () => {
          expectCommitToFail(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
        });

        it('fails to commit when SKIP_SIMPLE_GIT_HOOKS is set to "0"', () => {
          process.env.SKIP_SIMPLE_GIT_HOOKS = "0";
          expectCommitToFail(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
        });

        it("fails to commit when SKIP_SIMPLE_GIT_HOOKS is set to a random string", () => {
          process.env.SKIP_SIMPLE_GIT_HOOKS = "simple-git-hooks";
          expectCommitToFail(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
        });
      })

      describe("SIMPLE_GIT_HOOKS_RC", () => {
        afterEach(() => {
          delete process.env.SIMPLE_GIT_HOOKS_RC;
        });

        it("fails to commit when SIMPLE_GIT_HOOKS_RC is not set", () => {
          expectCommitToFail(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
        });

        it('commits successfully when SIMPLE_GIT_HOOKS_RC points to initrc_that_prevents_hook_fail.sh', () => {
          process.env.SIMPLE_GIT_HOOKS_RC = path.join(PROJECT_WITH_CONF_IN_PACKAGE_JSON, "initrc_that_prevents_hook_fail.sh");
          expectCommitToSucceed(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
        });

        it('fails to commit when SIMPLE_GIT_HOOKS_RC points to initrc_that_does_nothing.sh', () => {
          process.env.SIMPLE_GIT_HOOKS_RC = path.join(PROJECT_WITH_CONF_IN_PACKAGE_JSON, "initrc_that_does_nothing.sh");
          expectCommitToFail(PROJECT_WITH_CONF_IN_PACKAGE_JSON);
        });
      })
    });

    afterEach(() => {
      [
        PROJECT_WITH_CONF_IN_SEPARATE_JS_ALT,
        PROJECT_WITH_CONF_IN_SEPARATE_CJS_ALT,
        PROJECT_WITH_CONF_IN_SEPARATE_CJS,
        PROJECT_WITH_CONF_IN_SEPARATE_JS,
        PROJECT_WITH_CONF_IN_SEPARATE_JSON_ALT,
        PROJECT_WITH_CONF_IN_SEPARATE_JSON,
        PROJECT_WITH_CONF_IN_PACKAGE_JSON,
        PROJECT_WITH_BAD_CONF_IN_PACKAGE_JSON_,
        PROJECT_WO_CONF,
        PROJECT_WITH_CONF_IN_PACKAGE_JSON,
        PROJECT_WITH_UNUSED_CONF_IN_PACKAGE_JSON,
        PROJECT_WITH_CUSTOM_CONF,
      ].forEach((testCase) => {
        removeGitHooksFolder(testCase);
      });
    });
  })
})