@hanseltime/template-repo-sync 2.3.0 → 2.4.0-alpha.0

package/dist/cjs/template-sync.spec.js

@@ -0,0 +1,521 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _fs = require("fs");
+const _promises = require("fs/promises");
+const _fsextra = require("fs-extra");
+const _path = require("path");
+const _templatesync = require("./template-sync");
+const _testutils = require("./test-utils");
+const dummyCheckoutDriver = jest.fn();
+const dummyCurrentRefDriver = jest.fn();
+const downstreamDir = (0, _path.resolve)(_testutils.TEST_FIXTURES_DIR, "downstream");
+describe("templateSync", ()=>{
+    let tmpDir;
+    let templateDir;
+    let dummyCloneDriver;
+    beforeEach(async ()=>{
+        jest.resetAllMocks();
+        tmpDir = await (0, _promises.mkdtemp)((0, _testutils.tempDir)());
+        templateDir = await (0, _promises.mkdtemp)((0, _testutils.tempDir)());
+        await (0, _fsextra.copy)((0, _path.resolve)(_testutils.TEST_FIXTURES_DIR, "template"), templateDir);
+        await (0, _fsextra.copy)(downstreamDir, tmpDir);
+        dummyCloneDriver = async ()=>{
+            return {
+                dir: templateDir,
+                remoteName: "ourRemote"
+            };
+        };
+    });
+    afterEach(async ()=>{
+        await (0, _promises.rm)(tmpDir, {
+            force: true,
+            recursive: true
+        });
+    });
+    // Note: for this test, we expect actions and users to handle misconfigured template syncs
+    it.each([
+        [
+            "local",
+            `templatesync.local.json plugin option errors:
+\tPlugin (plugins/fail-validate-plugin.js):
+\t\toh no!
+\t\tnot this one too!
+`
+        ],
+        [
+            "template",
+            `templatesync.json plugin option errors:
+\tPlugin (dummy-fail-plugin.js):
+\t\tshucks
+\t\tno good
+`
+        ],
+        [
+            "both",
+            `templatesync.json plugin option errors:
+\tPlugin (dummy-fail-plugin.js):
+\t\tshucks
+\t\tno good
+templatesync.local.json plugin option errors:
+\tPlugin (plugins/fail-validate-plugin.js):
+\t\toh no!
+\t\tnot this one too!
+`
+        ]
+    ])("throws errors from plugin validation", async (mode, expected)=>{
+        // Remove the local sync overrides
+        await (0, _promises.rm)((0, _path.join)(tmpDir, "templatesync.local.json"));
+        if (mode === "local" || mode == "both") {
+            (0, _fs.writeFileSync)((0, _path.join)(tmpDir, "templatesync.local.json"), JSON.stringify({
+                ignore: [
+                    // Ignores the templated.ts
+                    "**/*.ts",
+                    // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                    "plugins/**"
+                ],
+                merge: [
+                    {
+                        glob: "package.json",
+                        plugin: "plugins/fail-validate-plugin.js",
+                        options: {}
+                    }
+                ]
+            }));
+        }
+        if (mode === "template" || mode === "both") {
+            (0, _fs.writeFileSync)((0, _path.join)(templateDir, "templatesync.json"), JSON.stringify({
+                ignore: [
+                    // Ignores the templated.ts
+                    "**/*.ts",
+                    // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                    "plugins/**"
+                ],
+                merge: [
+                    {
+                        glob: "package.json",
+                        plugin: "dummy-fail-plugin.js",
+                        options: {}
+                    }
+                ]
+            }));
+        }
+        await expect(async ()=>await (0, _templatesync.templateSync)({
+                tmpCloneDir: "stubbed-by-driver",
+                cloneDriver: dummyCloneDriver,
+                repoUrl: "not-important",
+                repoDir: tmpDir,
+                checkoutDriver: dummyCheckoutDriver,
+                currentRefDriver: dummyCurrentRefDriver
+            })).rejects.toThrow(expected);
+    });
+    it("appropriately merges according to just the templatesync config file into an empty dir", async ()=>{
+        const emptyTmpDir = await (0, _promises.mkdtemp)((0, _testutils.tempDir)());
+        expect(await (0, _templatesync.templateSync)({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: emptyTmpDir,
+            checkoutDriver: dummyCheckoutDriver,
+            currentRefDriver: dummyCurrentRefDriver
+        })).toEqual({
+            // Expect no changes since there was no local sync file
+            localSkipFiles: [],
+            localFileChanges: {},
+            modifiedFiles: {
+                added: [
+                    "package.json",
+                    "src/index.js",
+                    "src/templated.js",
+                    "src/templated.ts",
+                    "templatesync.json"
+                ],
+                deleted: [],
+                modified: [],
+                total: 5
+            }
+        });
+        // Verify the files
+        await fileMatchTemplate(emptyTmpDir, "templatesync.json");
+        await fileMatchTemplate(emptyTmpDir, "package.json");
+        await fileMatchTemplate(emptyTmpDir, "src/templated.ts");
+        // Expect the ignores to not be a problem
+        expect((0, _fs.existsSync)((0, _path.resolve)(emptyTmpDir, "src/index.ts"))).toBeFalsy();
+        expect((0, _fs.existsSync)((0, _path.resolve)(emptyTmpDir, "src/custom-bin"))).toBeFalsy();
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("Checks out the branch and then appropriately merges", async ()=>{
+        const emptyTmpDir = await (0, _promises.mkdtemp)((0, _testutils.tempDir)());
+        expect(await (0, _templatesync.templateSync)({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: emptyTmpDir,
+            branch: "new-template-test",
+            checkoutDriver: dummyCheckoutDriver,
+            currentRefDriver: dummyCurrentRefDriver
+        })).toEqual({
+            // Expect no changes since there was no local sync file
+            localSkipFiles: [],
+            localFileChanges: {},
+            modifiedFiles: {
+                added: [
+                    "package.json",
+                    "src/index.js",
+                    "src/templated.js",
+                    "src/templated.ts",
+                    "templatesync.json"
+                ],
+                deleted: [],
+                modified: [],
+                total: 5
+            }
+        });
+        // Verify the files
+        await fileMatchTemplate(emptyTmpDir, "templatesync.json");
+        await fileMatchTemplate(emptyTmpDir, "package.json");
+        await fileMatchTemplate(emptyTmpDir, "src/templated.ts");
+        // Expect the ignores to not be a problem
+        expect((0, _fs.existsSync)((0, _path.resolve)(emptyTmpDir, "src/index.ts"))).toBeFalsy();
+        expect((0, _fs.existsSync)((0, _path.resolve)(emptyTmpDir, "src/custom-bin"))).toBeFalsy();
+        const cloneInfo = await dummyCloneDriver();
+        expect(dummyCheckoutDriver).toHaveBeenCalledWith({
+            tmpDir: cloneInfo.dir,
+            remoteName: cloneInfo.remoteName,
+            branch: "new-template-test"
+        });
+    });
+    it("appropriately merges according to just the templatesync config file in an existing repo", async ()=>{
+        // Remove the local sync overrides
+        await (0, _promises.rm)((0, _path.join)(tmpDir, "templatesync.local.json"));
+        const result = await (0, _templatesync.templateSync)({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            checkoutDriver: dummyCheckoutDriver,
+            currentRefDriver: dummyCurrentRefDriver
+        });
+        expect(result.localSkipFiles).toEqual([]);
+        expect(result.localFileChanges).toEqual({});
+        // Verify the files
+        await fileMatchTemplate(tmpDir, "templatesync.json");
+        await fileMatchTemplate(tmpDir, "src/templated.ts");
+        const packageJson = JSON.parse((0, _fs.readFileSync)((0, _path.resolve)(tmpDir, "package.json")).toString());
+        expect(packageJson).toEqual({
+            name: "mypkg",
+            description: "my description",
+            dependencies: {
+                mypackage: "^1.2.0",
+                newpacakge: "^22.2.2",
+                package2: "3.22.1",
+                huh: "~1.0.0"
+            },
+            engines: {
+                node: ">=15"
+            },
+            scripts: {
+                build: "build",
+                test: "jest",
+                myscript: "somescript"
+            },
+            // By default we add new top-level fields
+            version: "new-version"
+        });
+        // Expect the ignores to not be a problem
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("appropriately merges according to the templatesync config file and the local config in an existing repo", async ()=>{
+        // Remove the local sync overrides
+        await (0, _promises.rm)((0, _path.join)(tmpDir, "templatesync.local.json"));
+        (0, _fs.writeFileSync)((0, _path.join)(tmpDir, "templatesync.local.json"), JSON.stringify({
+            ignore: [
+                // Ignores the templated.ts
+                "**/*.ts",
+                // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                "plugins/**"
+            ],
+            merge: [
+                {
+                    glob: "package.json",
+                    plugin: "plugins/custom-plugin.js",
+                    options: {}
+                }
+            ]
+        }));
+        const result = await (0, _templatesync.templateSync)({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            checkoutDriver: dummyCheckoutDriver,
+            currentRefDriver: dummyCurrentRefDriver
+        });
+        expect(result.localSkipFiles).toEqual([
+            "src/templated.ts"
+        ]);
+        // TODO: more rigorous testing around diff changes
+        expect(result.localFileChanges).toEqual(expect.objectContaining({
+            "package.json": expect.arrayContaining([])
+        }));
+        // Make sure the result captures the changes
+        expect(result.modifiedFiles).toEqual({
+            added: [
+                "package.json",
+                "src/index.js",
+                "src/templated.js",
+                "templatesync.json"
+            ],
+            deleted: [],
+            modified: [],
+            total: 4
+        });
+        // Verify the files
+        await fileMatchTemplate(tmpDir, "templatesync.json");
+        await fileMatchDownstream(tmpDir, "src/templated.ts");
+        const packageJson = JSON.parse((0, _fs.readFileSync)((0, _path.resolve)(tmpDir, "package.json")).toString());
+        // The plugin nuked this
+        expect(packageJson).toEqual({
+            downstream: true
+        });
+        // Expect the ignores to not be a problem
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("appropriately merges according to the templatesync config file and the local config in an existing repo with afterRef", async ()=>{
+        // Remove the local sync overrides
+        await (0, _promises.rm)((0, _path.join)(tmpDir, "templatesync.local.json"));
+        (0, _fs.writeFileSync)((0, _path.join)(tmpDir, "templatesync.local.json"), JSON.stringify({
+            afterRef: "dummySha",
+            ignore: [
+                // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                "plugins/**"
+            ]
+        }));
+        // We will only update the templated.ts
+        const mockDiffDriver = jest.fn().mockImplementation(async ()=>({
+                added: [
+                    "src/templated.ts"
+                ],
+                modified: [],
+                deleted: []
+            }));
+        const result = await (0, _templatesync.templateSync)({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            diffDriver: mockDiffDriver,
+            currentRefDriver: dummyCurrentRefDriver,
+            checkoutDriver: dummyCheckoutDriver
+        });
+        // since there was no override for this file, not changes from the local file
+        expect(result.localFileChanges).toEqual(expect.objectContaining({}));
+        // Verify the files
+        await fileMatchTemplate(tmpDir, "templatesync.json");
+        await fileMatchTemplate(tmpDir, "src/templated.ts");
+        // Expect the none of the diff files to work
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        await fileMatchDownstream(tmpDir, "package.json");
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("updates the local templatesync with the current ref if updateAfterRef is true", async ()=>{
+        // Remove the local sync overrides
+        await (0, _promises.rm)((0, _path.join)(tmpDir, "templatesync.local.json"));
+        const mockLocalConfig = {
+            afterRef: "dummySha",
+            ignore: [
+                // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                "plugins/**"
+            ]
+        };
+        (0, _fs.writeFileSync)((0, _path.join)(tmpDir, "templatesync.local.json"), JSON.stringify(mockLocalConfig));
+        // We will only update the templated.ts
+        const mockDiffDriver = jest.fn().mockImplementation(async ()=>({
+                added: [
+                    "src/templated.ts"
+                ],
+                modified: [
+                    "src/index.ts"
+                ],
+                deleted: []
+            }));
+        const mockCurrentRefDriver = jest.fn().mockImplementation(async ()=>"newestSha");
+        const result = await (0, _templatesync.templateSync)({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            updateAfterRef: true,
+            diffDriver: mockDiffDriver,
+            currentRefDriver: mockCurrentRefDriver,
+            checkoutDriver: dummyCheckoutDriver
+        });
+        // since there was no override for this file, no changes from the local file
+        expect(result.localFileChanges).toEqual(expect.objectContaining({}));
+        expect(result.modifiedFiles).toEqual({
+            added: [
+                "src/templated.ts"
+            ],
+            modified: [
+                "templatesync.local.json"
+            ],
+            deleted: [],
+            total: 2
+        });
+        // Verify the files
+        await fileMatchTemplate(tmpDir, "templatesync.json");
+        await fileMatchTemplate(tmpDir, "src/templated.ts");
+        // Expect the none of the diff files to work
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        await fileMatchDownstream(tmpDir, "package.json");
+        // Ensure we have updated the local template field
+        expect(JSON.parse((await (0, _promises.readFile)((0, _path.join)(tmpDir, "templatesync.local.json"))).toString())).toEqual({
+            ...mockLocalConfig,
+            afterRef: "newestSha"
+        });
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("Does not update the local templatesync if updateAfterRef is true and the ref is the same", async ()=>{
+        // Remove the local sync overrides
+        await (0, _promises.rm)((0, _path.join)(tmpDir, "templatesync.local.json"));
+        const mockLocalConfig = {
+            afterRef: "dummySha",
+            ignore: [
+                // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                "plugins/**"
+            ]
+        };
+        (0, _fs.writeFileSync)((0, _path.join)(tmpDir, "templatesync.local.json"), JSON.stringify(mockLocalConfig));
+        // We will only update the templated.ts
+        const mockDiffDriver = jest.fn().mockImplementation(async ()=>({
+                added: [
+                    "src/templated.ts"
+                ],
+                modified: [
+                    "src/index.ts"
+                ],
+                deleted: []
+            }));
+        const mockCurrentRefDriver = jest.fn().mockImplementation(async ()=>"dummySha");
+        const result = await (0, _templatesync.templateSync)({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            updateAfterRef: true,
+            diffDriver: mockDiffDriver,
+            currentRefDriver: mockCurrentRefDriver,
+            checkoutDriver: dummyCheckoutDriver
+        });
+        // Nothing shoudl be reported as changing
+        expect(result).toEqual({
+            localFileChanges: {},
+            localSkipFiles: [],
+            modifiedFiles: {
+                added: [],
+                modified: [],
+                deleted: [],
+                total: 0
+            }
+        });
+        // Verify the files
+        await fileMatchDownstream(tmpDir, "templatesync.json");
+        await fileMatchDownstream(tmpDir, "src/templated.ts");
+        // Expect the none of the diff files to work
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        await fileMatchDownstream(tmpDir, "package.json");
+        // Ensure we have updated the local template field
+        expect(JSON.parse((await (0, _promises.readFile)((0, _path.join)(tmpDir, "templatesync.local.json"))).toString())).toEqual({
+            ...mockLocalConfig
+        });
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("creates the local templatesync with the current ref if updateAfterRef is true and no local template exists", async ()=>{
+        // Remove the local sync overrides
+        await (0, _promises.rm)((0, _path.join)(tmpDir, "templatesync.local.json"));
+        // We will only update the templated.ts
+        const mockDiffDriver = jest.fn().mockImplementation(async ()=>({
+                added: [
+                    "src/templated.ts"
+                ]
+            }));
+        const mockCurrentRefDriver = jest.fn().mockImplementation(async ()=>"newestSha");
+        const result = await (0, _templatesync.templateSync)({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            updateAfterRef: true,
+            diffDriver: mockDiffDriver,
+            currentRefDriver: mockCurrentRefDriver,
+            checkoutDriver: dummyCheckoutDriver
+        });
+        // since there was no override for this file, no changes from the local file
+        expect(result.localFileChanges).toEqual(expect.objectContaining({}));
+        expect(result.modifiedFiles).toEqual({
+            added: [
+                "package.json",
+                "src/index.js",
+                "src/templated.js",
+                "src/templated.ts",
+                "templatesync.json",
+                "templatesync.local.json"
+            ],
+            deleted: [],
+            modified: [],
+            total: 6
+        });
+        // Verify the files
+        await fileMatchTemplate(tmpDir, "templatesync.json");
+        await fileMatchTemplate(tmpDir, "src/templated.ts");
+        const packageJson = JSON.parse((0, _fs.readFileSync)((0, _path.resolve)(tmpDir, "package.json")).toString());
+        expect(packageJson).toEqual({
+            name: "mypkg",
+            description: "my description",
+            dependencies: {
+                mypackage: "^1.2.0",
+                newpacakge: "^22.2.2",
+                package2: "3.22.1",
+                huh: "~1.0.0"
+            },
+            engines: {
+                node: ">=15"
+            },
+            scripts: {
+                build: "build",
+                test: "jest",
+                myscript: "somescript"
+            },
+            // By default we add new top-level fields
+            version: "new-version"
+        });
+        // Expect the none of the diff files to work
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        // Ensure we have updated the local template field
+        expect(JSON.parse((await (0, _promises.readFile)((0, _path.join)(tmpDir, "templatesync.local.json"))).toString())).toEqual({
+            afterRef: "newestSha"
+        });
+    });
+    // helper
+    async function fileMatchTemplate(_tmpDir, relPath) {
+        return fileMatch(_tmpDir, relPath, "template");
+    }
+    async function fileMatchDownstream(_tmpDir, relPath) {
+        return fileMatch(_tmpDir, relPath, "downstream");
+    }
+    async function fileMatch(_tmpDir, relPath, source) {
+        const dir = source === "downstream" ? downstreamDir : (await dummyCloneDriver()).dir;
+        expect((await (0, _promises.readFile)((0, _path.resolve)(_tmpDir, relPath))).toString()).toEqual((await (0, _promises.readFile)((0, _path.resolve)(dir, relPath))).toString());
+    }
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/template-sync.spec.ts"],"sourcesContent":["import { existsSync, readFileSync, writeFileSync } from \"fs\";\nimport { mkdtemp, readFile, rm } from \"fs/promises\";\nimport { copy } from \"fs-extra\";\nimport { join, resolve } from \"path\";\nimport { templateSync } from \"./template-sync\";\nimport { TEST_FIXTURES_DIR, tempDir } from \"./test-utils\";\n\nconst dummyCheckoutDriver = jest.fn();\nconst dummyCurrentRefDriver = jest.fn();\n\nconst downstreamDir = resolve(TEST_FIXTURES_DIR, \"downstream\");\n\ndescribe(\"templateSync\", () => {\n\tlet tmpDir: string;\n\tlet templateDir: string;\n\tlet dummyCloneDriver: () => Promise<{ dir: string; remoteName: string }>;\n\tbeforeEach(async () => {\n\t\tjest.resetAllMocks();\n\t\ttmpDir = await mkdtemp(tempDir());\n\t\ttemplateDir = await mkdtemp(tempDir());\n\t\tawait copy(resolve(TEST_FIXTURES_DIR, \"template\"), templateDir);\n\t\tawait copy(downstreamDir, tmpDir);\n\t\tdummyCloneDriver = async () => {\n\t\t\treturn {\n\t\t\t\tdir: templateDir,\n\t\t\t\tremoteName: \"ourRemote\",\n\t\t\t};\n\t\t};\n\t});\n\tafterEach(async () => {\n\t\tawait rm(tmpDir, {\n\t\t\tforce: true,\n\t\t\trecursive: true,\n\t\t});\n\t});\n\t// Note: for this test, we expect actions and users to handle misconfigured template syncs\n\tit.each([\n\t\t[\n\t\t\t\"local\",\n\t\t\t`templatesync.local.json plugin option errors:\n\\tPlugin (plugins/fail-validate-plugin.js):\n\\t\\toh no!\n\\t\\tnot this one too!\n`,\n\t\t],\n\t\t[\n\t\t\t\"template\",\n\t\t\t`templatesync.json plugin option errors:\n\\tPlugin (dummy-fail-plugin.js):\n\\t\\tshucks\n\\t\\tno good\n`,\n\t\t],\n\t\t[\n\t\t\t\"both\",\n\t\t\t`templatesync.json plugin option errors:\n\\tPlugin (dummy-fail-plugin.js):\n\\t\\tshucks\n\\t\\tno good\ntemplatesync.local.json plugin option errors:\n\\tPlugin (plugins/fail-validate-plugin.js):\n\\t\\toh no!\n\\t\\tnot this one too!\n`,\n\t\t],\n\t])(\"throws errors from plugin validation\", async (mode, expected) => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\tif (mode === \"local\" || mode == \"both\") {\n\t\t\twriteFileSync(\n\t\t\t\tjoin(tmpDir, \"templatesync.local.json\"),\n\t\t\t\tJSON.stringify({\n\t\t\t\t\tignore: [\n\t\t\t\t\t\t// Ignores the templated.ts\n\t\t\t\t\t\t\"**/*.ts\",\n\t\t\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\t\t\"plugins/**\",\n\t\t\t\t\t],\n\t\t\t\t\tmerge: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tglob: \"package.json\",\n\t\t\t\t\t\t\tplugin: \"plugins/fail-validate-plugin.js\",\n\t\t\t\t\t\t\toptions: {},\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t}),\n\t\t\t);\n\t\t}\n\t\tif (mode === \"template\" || mode === \"both\") {\n\t\t\twriteFileSync(\n\t\t\t\tjoin(templateDir, \"templatesync.json\"),\n\t\t\t\tJSON.stringify({\n\t\t\t\t\tignore: [\n\t\t\t\t\t\t// Ignores the templated.ts\n\t\t\t\t\t\t\"**/*.ts\",\n\t\t\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\t\t\"plugins/**\",\n\t\t\t\t\t],\n\t\t\t\t\tmerge: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tglob: \"package.json\",\n\t\t\t\t\t\t\tplugin: \"dummy-fail-plugin.js\",\n\t\t\t\t\t\t\toptions: {},\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t}),\n\t\t\t);\n\t\t}\n\n\t\tawait expect(\n\t\t\tasync () =>\n\t\t\t\tawait templateSync({\n\t\t\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\t\t\trepoUrl: \"not-important\",\n\t\t\t\t\trepoDir: tmpDir,\n\t\t\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t\t\t}),\n\t\t).rejects.toThrow(expected);\n\t});\n\tit(\"appropriately merges according to just the templatesync config file into an empty dir\", async () => {\n\t\tconst emptyTmpDir = await mkdtemp(tempDir());\n\t\texpect(\n\t\t\tawait templateSync({\n\t\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\t\trepoUrl: \"not-important\",\n\t\t\t\trepoDir: emptyTmpDir,\n\t\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t\t}),\n\t\t).toEqual({\n\t\t\t// Expect no changes since there was no local sync file\n\t\t\tlocalSkipFiles: [],\n\t\t\tlocalFileChanges: {},\n\t\t\tmodifiedFiles: {\n\t\t\t\tadded: [\n\t\t\t\t\t\"package.json\",\n\t\t\t\t\t\"src/index.js\",\n\t\t\t\t\t\"src/templated.js\",\n\t\t\t\t\t\"src/templated.ts\",\n\t\t\t\t\t\"templatesync.json\",\n\t\t\t\t],\n\t\t\t\tdeleted: [],\n\t\t\t\tmodified: [],\n\t\t\t\ttotal: 5,\n\t\t\t},\n\t\t});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(emptyTmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(emptyTmpDir, \"package.json\");\n\t\tawait fileMatchTemplate(emptyTmpDir, \"src/templated.ts\");\n\n\t\t// Expect the ignores to not be a problem\n\t\texpect(existsSync(resolve(emptyTmpDir, \"src/index.ts\"))).toBeFalsy();\n\t\texpect(existsSync(resolve(emptyTmpDir, \"src/custom-bin\"))).toBeFalsy();\n\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"Checks out the branch and then appropriately merges\", async () => {\n\t\tconst emptyTmpDir = await mkdtemp(tempDir());\n\t\texpect(\n\t\t\tawait templateSync({\n\t\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\t\trepoUrl: \"not-important\",\n\t\t\t\trepoDir: emptyTmpDir,\n\t\t\t\tbranch: \"new-template-test\",\n\t\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t\t}),\n\t\t).toEqual({\n\t\t\t// Expect no changes since there was no local sync file\n\t\t\tlocalSkipFiles: [],\n\t\t\tlocalFileChanges: {},\n\t\t\tmodifiedFiles: {\n\t\t\t\tadded: [\n\t\t\t\t\t\"package.json\",\n\t\t\t\t\t\"src/index.js\",\n\t\t\t\t\t\"src/templated.js\",\n\t\t\t\t\t\"src/templated.ts\",\n\t\t\t\t\t\"templatesync.json\",\n\t\t\t\t],\n\t\t\t\tdeleted: [],\n\t\t\t\tmodified: [],\n\t\t\t\ttotal: 5,\n\t\t\t},\n\t\t});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(emptyTmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(emptyTmpDir, \"package.json\");\n\t\tawait fileMatchTemplate(emptyTmpDir, \"src/templated.ts\");\n\n\t\t// Expect the ignores to not be a problem\n\t\texpect(existsSync(resolve(emptyTmpDir, \"src/index.ts\"))).toBeFalsy();\n\t\texpect(existsSync(resolve(emptyTmpDir, \"src/custom-bin\"))).toBeFalsy();\n\t\tconst cloneInfo = await dummyCloneDriver();\n\t\texpect(dummyCheckoutDriver).toHaveBeenCalledWith({\n\t\t\ttmpDir: cloneInfo.dir,\n\t\t\tremoteName: cloneInfo.remoteName,\n\t\t\tbranch: \"new-template-test\",\n\t\t});\n\t});\n\tit(\"appropriately merges according to just the templatesync config file in an existing repo\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t});\n\n\t\texpect(result.localSkipFiles).toEqual([]);\n\t\texpect(result.localFileChanges).toEqual({});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(tmpDir, \"src/templated.ts\");\n\t\tconst packageJson = JSON.parse(\n\t\t\treadFileSync(resolve(tmpDir, \"package.json\")).toString(),\n\t\t);\n\n\t\texpect(packageJson).toEqual({\n\t\t\tname: \"mypkg\",\n\t\t\tdescription: \"my description\",\n\t\t\tdependencies: {\n\t\t\t\tmypackage: \"^1.2.0\",\n\t\t\t\tnewpacakge: \"^22.2.2\",\n\t\t\t\tpackage2: \"3.22.1\",\n\t\t\t\thuh: \"~1.0.0\",\n\t\t\t},\n\t\t\tengines: {\n\t\t\t\tnode: \">=15\",\n\t\t\t},\n\t\t\tscripts: {\n\t\t\t\tbuild: \"build\",\n\t\t\t\ttest: \"jest\",\n\t\t\t\tmyscript: \"somescript\",\n\t\t\t},\n\t\t\t// By default we add new top-level fields\n\t\t\tversion: \"new-version\",\n\t\t});\n\n\t\t// Expect the ignores to not be a problem\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"appropriately merges according to the templatesync config file and the local config in an existing repo\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\twriteFileSync(\n\t\t\tjoin(tmpDir, \"templatesync.local.json\"),\n\t\t\tJSON.stringify({\n\t\t\t\tignore: [\n\t\t\t\t\t// Ignores the templated.ts\n\t\t\t\t\t\"**/*.ts\",\n\t\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\t\"plugins/**\",\n\t\t\t\t],\n\t\t\t\tmerge: [\n\t\t\t\t\t{\n\t\t\t\t\t\tglob: \"package.json\",\n\t\t\t\t\t\tplugin: \"plugins/custom-plugin.js\",\n\t\t\t\t\t\toptions: {},\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t}),\n\t\t);\n\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t});\n\n\t\texpect(result.localSkipFiles).toEqual([\"src/templated.ts\"]);\n\t\t// TODO: more rigorous testing around diff changes\n\t\texpect(result.localFileChanges).toEqual(\n\t\t\texpect.objectContaining({\n\t\t\t\t\"package.json\": expect.arrayContaining([]),\n\t\t\t}),\n\t\t);\n\t\t// Make sure the result captures the changes\n\t\texpect(result.modifiedFiles).toEqual({\n\t\t\tadded: [\n\t\t\t\t\"package.json\",\n\t\t\t\t\"src/index.js\",\n\t\t\t\t\"src/templated.js\",\n\t\t\t\t\"templatesync.json\",\n\t\t\t],\n\t\t\tdeleted: [],\n\t\t\tmodified: [],\n\t\t\ttotal: 4,\n\t\t});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchDownstream(tmpDir, \"src/templated.ts\");\n\t\tconst packageJson = JSON.parse(\n\t\t\treadFileSync(resolve(tmpDir, \"package.json\")).toString(),\n\t\t);\n\n\t\t// The plugin nuked this\n\t\texpect(packageJson).toEqual({\n\t\t\tdownstream: true,\n\t\t});\n\n\t\t// Expect the ignores to not be a problem\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"appropriately merges according to the templatesync config file and the local config in an existing repo with afterRef\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\twriteFileSync(\n\t\t\tjoin(tmpDir, \"templatesync.local.json\"),\n\t\t\tJSON.stringify({\n\t\t\t\tafterRef: \"dummySha\",\n\t\t\t\tignore: [\n\t\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\t\"plugins/**\",\n\t\t\t\t],\n\t\t\t}),\n\t\t);\n\n\t\t// We will only update the templated.ts\n\t\tconst mockDiffDriver = jest.fn().mockImplementation(async () => ({\n\t\t\tadded: [\"src/templated.ts\"],\n\t\t\tmodified: [],\n\t\t\tdeleted: [],\n\t\t}));\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tdiffDriver: mockDiffDriver,\n\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t});\n\n\t\t// since there was no override for this file, not changes from the local file\n\t\texpect(result.localFileChanges).toEqual(expect.objectContaining({}));\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(tmpDir, \"src/templated.ts\");\n\n\t\t// Expect the none of the diff files to work\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\t\tawait fileMatchDownstream(tmpDir, \"package.json\");\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"updates the local templatesync with the current ref if updateAfterRef is true\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\tconst mockLocalConfig = {\n\t\t\tafterRef: \"dummySha\",\n\t\t\tignore: [\n\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\"plugins/**\",\n\t\t\t],\n\t\t};\n\n\t\twriteFileSync(\n\t\t\tjoin(tmpDir, \"templatesync.local.json\"),\n\t\t\tJSON.stringify(mockLocalConfig),\n\t\t);\n\n\t\t// We will only update the templated.ts\n\t\tconst mockDiffDriver = jest.fn().mockImplementation(async () => ({\n\t\t\tadded: [\"src/templated.ts\"],\n\t\t\tmodified: [\"src/index.ts\"], // Add index.ts so we make sure it is still ignored - see test-fixtures/template/templatesync.json ignores\n\t\t\tdeleted: [],\n\t\t}));\n\t\tconst mockCurrentRefDriver = jest\n\t\t\t.fn()\n\t\t\t.mockImplementation(async () => \"newestSha\");\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tupdateAfterRef: true,\n\t\t\tdiffDriver: mockDiffDriver,\n\t\t\tcurrentRefDriver: mockCurrentRefDriver,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t});\n\n\t\t// since there was no override for this file, no changes from the local file\n\t\texpect(result.localFileChanges).toEqual(expect.objectContaining({}));\n\t\texpect(result.modifiedFiles).toEqual({\n\t\t\tadded: [\"src/templated.ts\"],\n\t\t\tmodified: [\"templatesync.local.json\"], // Add index.ts so we make sure it is still ignored - due to a bug\n\t\t\tdeleted: [],\n\t\t\ttotal: 2,\n\t\t});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(tmpDir, \"src/templated.ts\");\n\n\t\t// Expect the none of the diff files to work\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\t\tawait fileMatchDownstream(tmpDir, \"package.json\");\n\n\t\t// Ensure we have updated the local template field\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\t(await readFile(join(tmpDir, \"templatesync.local.json\"))).toString(),\n\t\t\t),\n\t\t).toEqual({\n\t\t\t...mockLocalConfig,\n\t\t\tafterRef: \"newestSha\",\n\t\t});\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"Does not update the local templatesync if updateAfterRef is true and the ref is the same\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\tconst mockLocalConfig = {\n\t\t\tafterRef: \"dummySha\",\n\t\t\tignore: [\n\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\"plugins/**\",\n\t\t\t],\n\t\t};\n\n\t\twriteFileSync(\n\t\t\tjoin(tmpDir, \"templatesync.local.json\"),\n\t\t\tJSON.stringify(mockLocalConfig),\n\t\t);\n\n\t\t// We will only update the templated.ts\n\t\tconst mockDiffDriver = jest.fn().mockImplementation(async () => ({\n\t\t\tadded: [\"src/templated.ts\"],\n\t\t\tmodified: [\"src/index.ts\"], // Add index.ts so we make sure it is still ignored - see test-fixtures/template/templatesync.json ignores\n\t\t\tdeleted: [],\n\t\t}));\n\t\tconst mockCurrentRefDriver = jest\n\t\t\t.fn()\n\t\t\t.mockImplementation(async () => \"dummySha\");\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tupdateAfterRef: true,\n\t\t\tdiffDriver: mockDiffDriver,\n\t\t\tcurrentRefDriver: mockCurrentRefDriver,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t});\n\n\t\t// Nothing shoudl be reported as changing\n\t\texpect(result).toEqual({\n\t\t\tlocalFileChanges: {},\n\t\t\tlocalSkipFiles: [],\n\t\t\tmodifiedFiles: {\n\t\t\t\tadded: [],\n\t\t\t\tmodified: [],\n\t\t\t\tdeleted: [],\n\t\t\t\ttotal: 0,\n\t\t\t},\n\t\t});\n\t\t// Verify the files\n\t\tawait fileMatchDownstream(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchDownstream(tmpDir, \"src/templated.ts\");\n\n\t\t// Expect the none of the diff files to work\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\t\tawait fileMatchDownstream(tmpDir, \"package.json\");\n\n\t\t// Ensure we have updated the local template field\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\t(await readFile(join(tmpDir, \"templatesync.local.json\"))).toString(),\n\t\t\t),\n\t\t).toEqual({\n\t\t\t...mockLocalConfig,\n\t\t});\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"creates the local templatesync with the current ref if updateAfterRef is true and no local template exists\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\t// We will only update the templated.ts\n\t\tconst mockDiffDriver = jest.fn().mockImplementation(async () => ({\n\t\t\tadded: [\"src/templated.ts\"],\n\t\t}));\n\t\tconst mockCurrentRefDriver = jest\n\t\t\t.fn()\n\t\t\t.mockImplementation(async () => \"newestSha\");\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tupdateAfterRef: true,\n\t\t\tdiffDriver: mockDiffDriver,\n\t\t\tcurrentRefDriver: mockCurrentRefDriver,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t});\n\n\t\t// since there was no override for this file, no changes from the local file\n\t\texpect(result.localFileChanges).toEqual(expect.objectContaining({}));\n\t\texpect(result.modifiedFiles).toEqual({\n\t\t\tadded: [\n\t\t\t\t\"package.json\",\n\t\t\t\t\"src/index.js\",\n\t\t\t\t\"src/templated.js\",\n\t\t\t\t\"src/templated.ts\",\n\t\t\t\t\"templatesync.json\",\n\t\t\t\t\"templatesync.local.json\",\n\t\t\t],\n\t\t\tdeleted: [],\n\t\t\tmodified: [],\n\t\t\ttotal: 6,\n\t\t});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(tmpDir, \"src/templated.ts\");\n\t\tconst packageJson = JSON.parse(\n\t\t\treadFileSync(resolve(tmpDir, \"package.json\")).toString(),\n\t\t);\n\n\t\texpect(packageJson).toEqual({\n\t\t\tname: \"mypkg\",\n\t\t\tdescription: \"my description\",\n\t\t\tdependencies: {\n\t\t\t\tmypackage: \"^1.2.0\",\n\t\t\t\tnewpacakge: \"^22.2.2\",\n\t\t\t\tpackage2: \"3.22.1\",\n\t\t\t\thuh: \"~1.0.0\",\n\t\t\t},\n\t\t\tengines: {\n\t\t\t\tnode: \">=15\",\n\t\t\t},\n\t\t\tscripts: {\n\t\t\t\tbuild: \"build\",\n\t\t\t\ttest: \"jest\",\n\t\t\t\tmyscript: \"somescript\",\n\t\t\t},\n\t\t\t// By default we add new top-level fields\n\t\t\tversion: \"new-version\",\n\t\t});\n\n\t\t// Expect the none of the diff files to work\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\n\t\t// Ensure we have updated the local template field\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\t(await readFile(join(tmpDir, \"templatesync.local.json\"))).toString(),\n\t\t\t),\n\t\t).toEqual({\n\t\t\tafterRef: \"newestSha\",\n\t\t});\n\t});\n\t// helper\n\tasync function fileMatchTemplate(_tmpDir: string, relPath: string) {\n\t\treturn fileMatch(_tmpDir, relPath, \"template\");\n\t}\n\n\tasync function fileMatchDownstream(_tmpDir: string, relPath: string) {\n\t\treturn fileMatch(_tmpDir, relPath, \"downstream\");\n\t}\n\n\tasync function fileMatch(\n\t\t_tmpDir: string,\n\t\trelPath: string,\n\t\tsource: \"downstream\" | \"template\",\n\t) {\n\t\tconst dir =\n\t\t\tsource === \"downstream\" ? downstreamDir : (await dummyCloneDriver()).dir;\n\t\texpect((await readFile(resolve(_tmpDir, relPath))).toString()).toEqual(\n\t\t\t(await readFile(resolve(dir, relPath))).toString(),\n\t\t);\n\t}\n});\n"],"names":["dummyCheckoutDriver","jest","fn","dummyCurrentRefDriver","downstreamDir","resolve","TEST_FIXTURES_DIR","describe","tmpDir","templateDir","dummyCloneDriver","beforeEach","resetAllMocks","mkdtemp","tempDir","copy","dir","remoteName","afterEach","rm","force","recursive","it","each","mode","expected","join","writeFileSync","JSON","stringify","ignore","merge","glob","plugin","options","expect","templateSync","tmpCloneDir","cloneDriver","repoUrl","repoDir","checkoutDriver","currentRefDriver","rejects","toThrow","emptyTmpDir","toEqual","localSkipFiles","localFileChanges","modifiedFiles","added","deleted","modified","total","fileMatchTemplate","existsSync","toBeFalsy","not","toHaveBeenCalled","branch","cloneInfo","toHaveBeenCalledWith","result","packageJson","parse","readFileSync","toString","name","description","dependencies","mypackage","newpacakge","package2","huh","engines","node","scripts","build","test","myscript","version","fileMatchDownstream","objectContaining","arrayContaining","downstream","afterRef","mockDiffDriver","mockImplementation","diffDriver","mockLocalConfig","mockCurrentRefDriver","updateAfterRef","readFile","_tmpDir","relPath","fileMatch","source"],"mappings":"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"}

package/dist/cjs/test-utils/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TEST_FIXTURES_DIR: function() {
+        return TEST_FIXTURES_DIR;
+    },
+    tempDir: function() {
+        return tempDir;
+    }
+});
+const _os = require("os");
+const _path = require("path");
+const TEST_FIXTURES_DIR = (0, _path.resolve)(__dirname, "..", "..", "test-fixtures");
+function tempDir() {
+    return process.env.RUNNER_TEMP ?? (0, _os.tmpdir)();
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90ZXN0LXV0aWxzL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHRtcGRpciB9IGZyb20gXCJvc1wiO1xuaW1wb3J0IHsgcmVzb2x2ZSB9IGZyb20gXCJwYXRoXCI7XG5cbmV4cG9ydCBjb25zdCBURVNUX0ZJWFRVUkVTX0RJUiA9IHJlc29sdmUoXG5cdF9fZGlybmFtZSxcblx0XCIuLlwiLFxuXHRcIi4uXCIsXG5cdFwidGVzdC1maXh0dXJlc1wiLFxuKTtcblxuZXhwb3J0IGZ1bmN0aW9uIHRlbXBEaXIoKTogc3RyaW5nIHtcblx0cmV0dXJuIHByb2Nlc3MuZW52LlJVTk5FUl9URU1QID8/IHRtcGRpcigpO1xufVxuIl0sIm5hbWVzIjpbIlRFU1RfRklYVFVSRVNfRElSIiwidGVtcERpciIsInJlc29sdmUiLCJfX2Rpcm5hbWUiLCJwcm9jZXNzIiwiZW52IiwiUlVOTkVSX1RFTVAiLCJ0bXBkaXIiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0lBR2FBLGlCQUFpQjtlQUFqQkE7O0lBT0dDLE9BQU87ZUFBUEE7OztvQkFWTztzQkFDQztBQUVqQixNQUFNRCxvQkFBb0JFLElBQUFBLGFBQU8sRUFDdkNDLFdBQ0EsTUFDQSxNQUNBO0FBR00sU0FBU0Y7SUFDZixPQUFPRyxRQUFRQyxHQUFHLENBQUNDLFdBQVcsSUFBSUMsSUFBQUEsVUFBTTtBQUN6QyJ9

package/dist/cjs/types.js

@@ -0,0 +1,12 @@
+/**
+ * How we want to merge json
+ *
+ * overwrite - the template sync overwrites completely
+ * merge-template - we merge template into the current json with overrides on matching values happening from the template
+ * merge-current - we merge the current json into the template json with overrides on matching values happening from the current json
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,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