@hanseltime/template-repo-sync 2.0.2 → 2.1.0

package/src/merge-file.spec.ts

@@ -3,22 +3,30 @@ import { mergeFile } from "./merge-file";
 import { tempDir, TEST_FIXTURES_DIR } from "./test-utils";
 import { mkdtemp, readFile, rm } from "fs/promises";
 import { copySync } from "fs-extra";
-import { JsonFileMergeOptions } from "./types";
+import { FileOperation, JsonFileMergeOptions } from "./types";
+import { existsSync } from "fs";
 
 const testTemplateDir = resolve(TEST_FIXTURES_DIR, "template");
 const testDownstreamDir = resolve(TEST_FIXTURES_DIR, "downstream");
 
 describe("mergeFile", () => {
   let tmpDir: string;
+  let tmpTargetDir: string;
   beforeEach(async () => {
     tmpDir = await mkdtemp(tempDir());
     copySync(testDownstreamDir, tmpDir);
+    tmpTargetDir = await mkdtemp(tempDir());
+    copySync(testTemplateDir, tmpTargetDir);
   });
   afterEach(async () => {
     await rm(tmpDir, {
       force: true,
       recursive: true,
     });
+    await rm(tmpTargetDir, {
+      force: true,
+      recursive: true,
+    });
   });
   // Note: we use the "ignore" from the templateSync to constrain files we iterate over so it doeesn't happen here
   // it('skips the file if it is part of template config ignroe', async () => {
@@ -35,69 +43,65 @@ describe("mergeFile", () => {
   //         }
   //     })).toBe(false)
   // })
-  it("skips the file if it is part of local config ignore", async () => {
-    expect(
-      await mergeFile("package.json", {
-        cwd: tmpDir,
-        tempCloneDir: testTemplateDir,
-        localTemplateSyncConfig: {
-          ignore: ["**/package.json"],
-          merge: [],
-        },
-        templateSyncConfig: {
-          ignore: ["**/*.txt"],
-        },
-      }),
-    ).toEqual({
-      ignoredDueToLocal: true,
-    });
-  });
-  it("overwrites if no merge config for files", async () => {
-    expect(
-      await mergeFile("package.json", {
-        cwd: tmpDir,
-        tempCloneDir: testTemplateDir,
-        localTemplateSyncConfig: {
-          ignore: [],
-        },
-        templateSyncConfig: {
-          ignore: ["**/*.txt"],
-        },
-      }),
-    ).toEqual({
-      ignoredDueToLocal: false,
-      localChanges: [],
-    });
+  it.each([["added"], ["deleted"], ["modified"]])(
+    "skips the [%s] file if it is part of local config ignore",
+    async (op) => {
+      expect(
+        await mergeFile("package.json", {
+          cwd: tmpDir,
+          tempCloneDir: tmpTargetDir,
+          localTemplateSyncConfig: {
+            ignore: ["**/package.json"],
+            merge: [],
+          },
+          templateSyncConfig: {
+            ignore: ["**/*.txt"],
+          },
+          fileOperation: op as FileOperation,
+        }),
+      ).toEqual({
+        ignoredDueToLocal: true,
+      });
+    },
+  );
+  it.each([["added"], ["modified"]])(
+    "overwrites if no merge config for [%s] files",
+    async (op) => {
+      expect(
+        await mergeFile("package.json", {
+          cwd: tmpDir,
+          tempCloneDir: tmpTargetDir,
+          localTemplateSyncConfig: {
+            ignore: [],
+          },
+          templateSyncConfig: {
+            ignore: ["**/*.txt"],
+          },
+          fileOperation: op as FileOperation,
+        }),
+      ).toEqual({
+        ignoredDueToLocal: false,
+        localChanges: [],
+      });
 
-    // Ensure we overwrote
-    expect(await readFile(join(tmpDir, "package.json"))).toEqual(
-      await readFile(join(testTemplateDir, "package.json")),
-    );
-  });
-  // Yea... these are more integration tests but I'm kinda untrusting of mocks for this
-  it("applies default [.json] merge with first rules if merge applies to file", async () => {
+      // Ensure we overwrote
+      expect(await readFile(join(tmpDir, "package.json"))).toEqual(
+        await readFile(join(tmpTargetDir, "package.json")),
+      );
+    },
+  );
+  it("removes the template deleted files", async () => {
     expect(
       await mergeFile("package.json", {
         cwd: tmpDir,
-        tempCloneDir: testTemplateDir,
+        tempCloneDir: tmpTargetDir,
         localTemplateSyncConfig: {
           ignore: [],
         },
         templateSyncConfig: {
           ignore: ["**/*.txt"],
-          merge: [
-            {
-              glob: "**/package.json",
-              options: "merge-current",
-              plugin: "_json",
-            },
-            {
-              glob: "**/package.json",
-              options: "merge-template",
-              plugin: "_json",
-            },
-          ],
         },
+        fileOperation: "deleted", // This is normally inferred by the top-level code
       }),
     ).toEqual({
       ignoredDueToLocal: false,
@@ -105,85 +109,15 @@ describe("mergeFile", () => {
     });
 
     // Ensure we overwrote
-    expect(
-      JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
-    ).toEqual({
-      name: "mypkg",
-      description: "my description",
-      dependencies: {
-        mypackage: "^1.2.0",
-        newpacakge: "^22.2.2",
-        package2: "3.22.1",
-        huh: "^2.30.0",
-      },
-      engines: {
-        node: ">=20",
-      },
-      scripts: {
-        build: "build",
-        test: "jest",
-        myscript: "somescript",
-      },
-      version: "new-version",
-    });
+    expect(existsSync(join(tmpTargetDir, "package.json"))).toBeFalsy();
   });
-  it("[inverse] applies default [.json] merge with first rules if merge applies to file", async () => {
-    expect(
-      await mergeFile("package.json", {
-        cwd: tmpDir,
-        tempCloneDir: testTemplateDir,
-        localTemplateSyncConfig: {
-          ignore: [],
-        },
-        templateSyncConfig: {
-          ignore: ["**/*.txt"],
-          merge: [
-            {
-              glob: "**/package.json",
-              options: "merge-template",
-              plugin: "_json",
-            },
-            {
-              glob: "**/package.json",
-              options: "merge-current",
-              plugin: "_json",
-            },
-          ],
-        },
-      }),
-    ).toEqual({
-      ignoredDueToLocal: false,
-      localChanges: [],
-    });
 
-    // Ensure we overwrote
-    expect(
-      JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
-    ).toEqual({
-      name: "some-stub-name",
-      description: "some-stub-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: "fill this in yourself",
-        myscript: "somescript",
-      },
-      version: "new-version",
-    });
-  });
-  it("[inverse] applies default [.json] merge with sync and then local override", async () => {
+  // TODO - this could change if there's a use case
+  it("does not apply plugins on deleted", async () => {
     expect(
       await mergeFile("package.json", {
         cwd: tmpDir,
-        tempCloneDir: testTemplateDir,
+        tempCloneDir: tmpTargetDir,
         localTemplateSyncConfig: {
           ignore: [],
           merge: [
@@ -215,94 +149,253 @@ describe("mergeFile", () => {
             },
           ],
         },
+        fileOperation: "deleted", // This is normally inferred by the top-level code
       }),
     ).toEqual({
       ignoredDueToLocal: false,
-      localChanges: expect.arrayContaining([
-        {
-          added: undefined,
-          count: 1,
-          removed: true,
-          value: '    "huh": "~1.0.0"\n',
-        },
-        {
-          added: true,
-          count: 1,
-          removed: undefined,
-          value: '    "huh": "^2.30.0"\n',
-        },
-      ]),
+      localChanges: [],
     });
 
     // Ensure we overwrote
-    expect(
-      JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
-    ).toEqual({
-      name: "mypkg",
-      description: "my description",
-      dependencies: {
-        mypackage: "^1.2.0",
-        newpacakge: "^22.2.2",
-        package2: "3.22.1",
-        huh: "^2.30.0",
-      },
-      engines: {
-        node: ">=20",
-      },
-      scripts: {
-        build: "build",
-        test: "jest",
-        myscript: "somescript",
-      },
-      version: "new-version",
-    });
+    expect(existsSync(join(tmpTargetDir, "package.json"))).toBeFalsy();
   });
-  it("[inverse] applies default [.json] and custom merge for local with sync and then local override", async () => {
-    expect(
-      await mergeFile("package.json", {
-        cwd: tmpDir,
-        tempCloneDir: testTemplateDir,
-        localTemplateSyncConfig: {
-          ignore: [],
-          merge: [
+
+  describe.each([["added" as FileOperation], ["modified" as FileOperation]])(
+    "[%s] file",
+    (op: FileOperation) => {
+      // Yea... these are more integration tests but I'm kinda untrusting of mocks for this
+      it("applies default [.json] merge with first rules if merge applies to file", async () => {
+        expect(
+          await mergeFile("package.json", {
+            cwd: tmpDir,
+            tempCloneDir: testTemplateDir,
+            localTemplateSyncConfig: {
+              ignore: [],
+            },
+            fileOperation: op,
+            templateSyncConfig: {
+              ignore: ["**/*.txt"],
+              merge: [
+                {
+                  glob: "**/package.json",
+                  options: "merge-current",
+                  plugin: "_json",
+                },
+                {
+                  glob: "**/package.json",
+                  options: "merge-template",
+                  plugin: "_json",
+                },
+              ],
+            },
+          }),
+        ).toEqual({
+          ignoredDueToLocal: false,
+          localChanges: [],
+        });
+
+        // Ensure we overwrote
+        expect(
+          JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
+        ).toEqual({
+          name: "mypkg",
+          description: "my description",
+          dependencies: {
+            mypackage: "^1.2.0",
+            newpacakge: "^22.2.2",
+            package2: "3.22.1",
+            huh: "^2.30.0",
+          },
+          engines: {
+            node: ">=20",
+          },
+          scripts: {
+            build: "build",
+            test: "jest",
+            myscript: "somescript",
+          },
+          version: "new-version",
+        });
+      });
+      it("[inverse] applies default [.json] merge with first rules if merge applies to file", async () => {
+        expect(
+          await mergeFile("package.json", {
+            cwd: tmpDir,
+            tempCloneDir: testTemplateDir,
+            localTemplateSyncConfig: {
+              ignore: [],
+            },
+            fileOperation: op,
+            templateSyncConfig: {
+              ignore: ["**/*.txt"],
+              merge: [
+                {
+                  glob: "**/package.json",
+                  options: "merge-template",
+                  plugin: "_json",
+                },
+                {
+                  glob: "**/package.json",
+                  options: "merge-current",
+                  plugin: "_json",
+                },
+              ],
+            },
+          }),
+        ).toEqual({
+          ignoredDueToLocal: false,
+          localChanges: [],
+        });
+
+        // Ensure we overwrote
+        expect(
+          JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
+        ).toEqual({
+          name: "some-stub-name",
+          description: "some-stub-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: "fill this in yourself",
+            myscript: "somescript",
+          },
+          version: "new-version",
+        });
+      });
+      it("[inverse] applies default [.json] merge with sync and then local override", async () => {
+        expect(
+          await mergeFile("package.json", {
+            cwd: tmpDir,
+            tempCloneDir: testTemplateDir,
+            fileOperation: op,
+            localTemplateSyncConfig: {
+              ignore: [],
+              merge: [
+                {
+                  plugin: "_json",
+                  glob: "**/package.json",
+                  options: {
+                    paths: [
+                      // Do not touch huh
+                      ["$.dependencies.huh", "merge-current"],
+                    ],
+                  },
+                },
+              ],
+            },
+            templateSyncConfig: {
+              ignore: ["**/*.txt"],
+              merge: [
+                {
+                  glob: "**/package.json",
+                  plugin: "_json",
+                  options: {
+                    missingIsDelete: true,
+                    paths: [
+                      // Merge all template dependencies
+                      ["$.dependencies", "merge-template"],
+                    ],
+                  } as JsonFileMergeOptions,
+                },
+              ],
+            },
+          }),
+        ).toEqual({
+          ignoredDueToLocal: false,
+          localChanges: expect.arrayContaining([
             {
-              plugin: "../test-fixtures/dummy-plugin.js",
-              options: {
-                paths: [
-                  // Do not touch huh
-                  ["$.dependencies.huh", "merge-current"],
-                ],
-              },
-              glob: "**/package.json",
+              added: undefined,
+              count: 1,
+              removed: true,
+              value: '    "huh": "~1.0.0"\n',
             },
-          ],
-        },
-        templateSyncConfig: {
-          ignore: ["**/*.txt"],
-          merge: [
             {
-              plugin: "_json",
-              glob: "**/package.json",
-              options: {
-                missingIsDelete: true,
-                paths: [
-                  // Merge all template dependencies
-                  ["$.dependencies", "merge-template"],
-                ],
-              } as JsonFileMergeOptions,
+              added: true,
+              count: 1,
+              removed: undefined,
+              value: '    "huh": "^2.30.0"\n',
             },
-          ],
-        },
-      }),
-    ).toEqual({
-      ignoredDueToLocal: false,
-      // TODO: I don't
-      localChanges: expect.arrayContaining([
-        {
-          added: undefined,
-          count: 17,
-          removed: true,
-          value: `  "name": "mypkg",
+          ]),
+        });
+
+        // Ensure we overwrote
+        expect(
+          JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
+        ).toEqual({
+          name: "mypkg",
+          description: "my description",
+          dependencies: {
+            mypackage: "^1.2.0",
+            newpacakge: "^22.2.2",
+            package2: "3.22.1",
+            huh: "^2.30.0",
+          },
+          engines: {
+            node: ">=20",
+          },
+          scripts: {
+            build: "build",
+            test: "jest",
+            myscript: "somescript",
+          },
+          version: "new-version",
+        });
+      });
+      it("[inverse] applies default [.json] and custom merge for local with sync and then local override", async () => {
+        expect(
+          await mergeFile("package.json", {
+            cwd: tmpDir,
+            tempCloneDir: testTemplateDir,
+            fileOperation: op,
+            localTemplateSyncConfig: {
+              ignore: [],
+              merge: [
+                {
+                  plugin: "../test-fixtures/dummy-plugin.js",
+                  options: {
+                    paths: [
+                      // Do not touch huh
+                      ["$.dependencies.huh", "merge-current"],
+                    ],
+                  },
+                  glob: "**/package.json",
+                },
+              ],
+            },
+            templateSyncConfig: {
+              ignore: ["**/*.txt"],
+              merge: [
+                {
+                  plugin: "_json",
+                  glob: "**/package.json",
+                  options: {
+                    missingIsDelete: true,
+                    paths: [
+                      // Merge all template dependencies
+                      ["$.dependencies", "merge-template"],
+                    ],
+                  } as JsonFileMergeOptions,
+                },
+              ],
+            },
+          }),
+        ).toEqual({
+          ignoredDueToLocal: false,
+          // TODO: I don't
+          localChanges: expect.arrayContaining([
+            {
+              added: undefined,
+              count: 17,
+              removed: true,
+              value: `  "name": "mypkg",
   "description": "my description",
   "dependencies": {
     "mypackage": "^1.2.0",
@@ -319,92 +412,95 @@ describe("mergeFile", () => {
     "myscript": "somescript"
   },
   "version": "new-version"\n`,
-        },
-        {
-          added: true,
-          count: 1,
-          removed: undefined,
-          value: `    "tested": true\n`,
-        },
-      ]),
-    });
-
-    // Ensure we overwrote
-    expect(
-      JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
-    ).toEqual({
-      tested: true,
-    });
-  });
-  it("[inverse] applies builtin _json and custom merge for local with sync plugin and then local override", async () => {
-    expect(
-      await mergeFile("package.json", {
-        cwd: tmpDir,
-        tempCloneDir: testTemplateDir,
-        localTemplateSyncConfig: {
-          ignore: [],
-          merge: [
-            {
-              glob: "**/package.json",
-              plugin: "plugins/custom-plugin.js",
-              options: {
-                paths: [
-                  // Do not touch huh
-                  ["$.dependencies.huh", "merge-current"],
-                ],
-              },
             },
-          ],
-        },
-        templateSyncConfig: {
-          ignore: ["**/*.txt"],
-          merge: [
             {
-              glob: "**/package.json",
-              // TODO - we need to handle the weird implicit case I added here.  It's dumb
-              options: {
-                missingIsDelete: true,
-                paths: [
-                  // Merge all template dependencies
-                  ["$.dependencies", "merge-template"],
-                ],
-              } as JsonFileMergeOptions,
-              plugin: "_json",
+              added: true,
+              count: 1,
+              removed: undefined,
+              value: `    "tested": true\n`,
             },
-          ],
-          //   ".json": {
-          //     // no plugins
-          //     rules: [
-          //       {
-          //         glob: "**/package.json",
-          //         options: {
-          //           missingIsDelete: true,
-          //           paths: [
-          //             // Merge all template dependencies
-          //             ["$.dependencies", "merge-template"],
-          //           ],
-          //         } as JsonFileMergeOptions,
-          //       },
-          //       {
-          //         glob: "**/package.json",
-          //         options: "merge-current",
-          //       },
-          //     ],
-          //   },
-          // },
-        },
-      }),
-    ).toEqual({
-      ignoredDueToLocal: false,
-      // We are just making sure plugin look up happens here
-      localChanges: expect.arrayContaining([]),
-    });
+          ]),
+        });
 
-    // Ensure we overwrote
-    expect(
-      JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
-    ).toEqual({
-      downstream: true,
-    });
-  });
+        // Ensure we overwrote
+        expect(
+          JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
+        ).toEqual({
+          tested: true,
+        });
+      });
+      it("[inverse] applies builtin _json and custom merge for local with sync plugin and then local override", async () => {
+        expect(
+          await mergeFile("package.json", {
+            cwd: tmpDir,
+            tempCloneDir: testTemplateDir,
+            fileOperation: op,
+            localTemplateSyncConfig: {
+              ignore: [],
+              merge: [
+                {
+                  glob: "**/package.json",
+                  plugin: "plugins/custom-plugin.js",
+                  options: {
+                    paths: [
+                      // Do not touch huh
+                      ["$.dependencies.huh", "merge-current"],
+                    ],
+                  },
+                },
+              ],
+            },
+            templateSyncConfig: {
+              ignore: ["**/*.txt"],
+              merge: [
+                {
+                  glob: "**/package.json",
+                  // TODO - we need to handle the weird implicit case I added here.  It's dumb
+                  options: {
+                    missingIsDelete: true,
+                    paths: [
+                      // Merge all template dependencies
+                      ["$.dependencies", "merge-template"],
+                    ],
+                  } as JsonFileMergeOptions,
+                  plugin: "_json",
+                },
+              ],
+              //   ".json": {
+              //     // no plugins
+              //     rules: [
+              //       {
+              //         glob: "**/package.json",
+              //         options: {
+              //           missingIsDelete: true,
+              //           paths: [
+              //             // Merge all template dependencies
+              //             ["$.dependencies", "merge-template"],
+              //           ],
+              //         } as JsonFileMergeOptions,
+              //       },
+              //       {
+              //         glob: "**/package.json",
+              //         options: "merge-current",
+              //       },
+              //     ],
+              //   },
+              // },
+            },
+          }),
+        ).toEqual({
+          ignoredDueToLocal: false,
+          // We are just making sure plugin look up happens here
+          localChanges: expect.arrayContaining([]),
+        });
+
+        // Ensure we overwrote
+        expect(
+          JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
+        ).toEqual({
+          downstream: true,
+        });
+      });
+    },
+  );
 });