test: parametrize first two tests

Author: jbroma

packages/repack/src/modules/ScriptManager/__tests__/ScriptManagerHooks.test.ts

@@ -45,59 +45,67 @@ afterEach(() => {
 });
 
 describe('ScriptManager hooks', () => {
-  it('should sequentially call hooks in series', async () => {
-    const executionOrder: string[] = [];
-    ['first', 'second', 'third'].forEach((prefix) => {
-      ScriptManager.shared.hooks.beforeResolve(async (args) => {
-        executionOrder.push(`${prefix}-beforeResolve`);
-        return {
-          options: {
-            ...args.options,
-            scriptId: `${prefix}-${args.options.scriptId}`,
-          },
-        };
+  it.each([
+    ['beforeResolve', 'resolveScript'],
+    ['afterResolve', 'resolveScript'],
+    ['beforeLoad', 'loadScript'],
+    ['afterLoad', 'loadScript'],
+  ] as const)(
+    'should sequentially call hook in series - %s',
+    async (hookName, methodName) => {
+      const executionOrder: string[] = [];
+      ['first', 'second', 'third'].forEach((prefix) => {
+        ScriptManager.shared.hooks[hookName](async (args) => {
+          executionOrder.push(`${prefix}-${hookName}`);
+          return args as any;
+        });
       });
-    });
-
-    ScriptManager.shared.addResolver(async (scriptId) => {
-      return { url: Script.getRemoteURL(`http://domain.ext/${scriptId}`) };
-    });
-
-    await ScriptManager.shared.resolveScript('test-script', 'test-caller');
-
-    expect(executionOrder).toEqual([
-      'first-beforeResolve',
-      'second-beforeResolve',
-      'third-beforeResolve',
-    ]);
-  });
 
-  it('should pass args between hooks using waterfall pattern', async () => {
-    ['first', 'second', 'third'].forEach((prefix) => {
-      ScriptManager.shared.hooks.beforeResolve(async (args) => {
-        return {
-          options: {
-            ...args.options,
-            scriptId: `${prefix}-${args.options.scriptId}`,
-          },
-        };
+      ScriptManager.shared.addResolver(async (scriptId) => {
+        return { url: Script.getRemoteURL(`http://domain.ext/${scriptId}`) };
+      });
+
+      await ScriptManager.shared[methodName]('test-script', 'test-caller');
+
+      expect(executionOrder).toEqual([
+        `first-${hookName}`,
+        `second-${hookName}`,
+        `third-${hookName}`,
+      ]);
+    }
+  );
+
+  it.each([
+    ['beforeResolve', 'resolveScript'],
+    ['afterResolve', 'resolveScript'],
+    ['beforeLoad', 'loadScript'],
+    ['afterLoad', 'loadScript'],
+  ] as const)(
+    'should pass args between hooks using waterfall pattern - %s',
+    async (hookName, methodName) => {
+      let testScriptId: string;
+      let testCaller: string;
+
+      ['first', 'second', 'third'].forEach((prefix) => {
+        ScriptManager.shared.hooks[hookName](async (args) => {
+          args.options.scriptId =
+            testScriptId = `${prefix}-${args.options.scriptId}`;
+          args.options.caller = testCaller = `${prefix}-${args.options.caller}`;
+
+          return args as any;
+        });
       });
-    });
 
-    ScriptManager.shared.addResolver(async (scriptId) => {
-      return { url: Script.getRemoteURL(`http://domain.ext/${scriptId}`) };
-    });
+      ScriptManager.shared.addResolver(async (scriptId) => {
+        return { url: Script.getRemoteURL(`http://domain.ext/${scriptId}`) };
+      });
 
-    const script = await ScriptManager.shared.resolveScript(
-      'test-script',
-      'test-caller'
-    );
+      await ScriptManager.shared[methodName]('test-script', 'test-caller');
 
-    expect(script.scriptId).toBe('third-second-first-test-script');
-    expect(script.locator.url).toBe(
-      'http://domain.ext/third-second-first-test-script.chunk.bundle'
-    );
-  });
+      expect(testScriptId!).toBe('third-second-first-test-script');
+      expect(testCaller!).toBe('third-second-first-test-caller');
+    }
+  );
 
   describe('resolve hooks', () => {
     it('should call resolve hooks in correct lifecycle order', async () => {