@bluelibs/runner 2.2.4 → 3.1.0

package/src/__tests__/models/Store.test.ts

@@ -127,4 +127,44 @@ describe("Store", () => {
       /Store already initialized/i
     );
   });
+
+  it("should access overrides and overrideRequests getters", () => {
+    // Test the overrides getter (line 56)
+    const overrides = store.overrides;
+    expect(overrides).toBeDefined();
+    expect(overrides instanceof Map).toBe(true);
+
+    // Test the overrideRequests getter (line 57)
+    const overrideRequests = store.overrideRequests;
+    expect(overrideRequests).toBeDefined();
+    expect(overrideRequests instanceof Set).toBe(true);
+  });
+
+  it("should call processOverrides method", () => {
+    // Test processOverrides method (line 149)
+    expect(() => store.processOverrides()).not.toThrow();
+  });
+
+  it("should call getEverywhereMiddlewareForTasks method", () => {
+    // Test getEverywhereMiddlewareForTasks method (lines 152-153)
+    const result = store.getEverywhereMiddlewareForTasks([]);
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  it("should call getEverywhereMiddlewareForResources method", () => {
+    // Test getEverywhereMiddlewareForResources method (lines 156-157)
+    const result = store.getEverywhereMiddlewareForResources([]);
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  it("should call storeEventsForAllTasks method", () => {
+    // Test storeEventsForAllTasks method (line 165)
+    expect(() => store.storeEventsForAllTasks()).not.toThrow();
+  });
+
+  it("should call getDependentNodes method", () => {
+    // Test getDependentNodes method (line 169)
+    const result = store.getDependentNodes();
+    expect(Array.isArray(result)).toBe(true);
+  });
 });

package/src/__tests__/models/TaskRunner.test.ts

@@ -4,6 +4,7 @@ import { EventManager } from "../../models/EventManager";
 import { defineTask, defineResource, defineMiddleware } from "../../define";
 import { ITask } from "../../defs";
 import { Logger } from "../../models";
+import { globalEvents } from "../../globals/globalEvents";
 
 describe("TaskRunner", () => {
   let store: Store;
@@ -42,16 +43,16 @@ describe("TaskRunner", () => {
   it("should run an task with middleware", async () => {
     const middleware1 = defineMiddleware({
       id: "middleware1",
-      run: async ({ next, input }) => {
-        const result = await next(input);
+      run: async ({ next, task }) => {
+        const result = await next(task?.input);
         return result + 1;
       },
     });
 
     const middleware2 = defineMiddleware({
       id: "middleware2",
-      run: async ({ input, next }) => {
-        const result = await next(input);
+      run: async ({ task, next }, deps, config) => {
+        const result = await next(task?.input);
         return result * 2;
       },
     });
@@ -104,8 +105,22 @@ describe("TaskRunner", () => {
       expect.objectContaining({ data: { input: 5 } })
     );
     expect(afterRunSpy).toHaveBeenCalledWith(
-      expect.objectContaining({ data: { input: 5, output: 10 } })
+      expect.objectContaining({
+        data: expect.objectContaining({
+          input: 5,
+          output: 10,
+          setOutput: expect.any(Function),
+        }),
+      })
     );
+
+    // Verify that the output getter actually works
+    const afterRunCall = afterRunSpy.mock.calls[0][0];
+    expect(afterRunCall.data.output).toBe(10);
+
+    // Also test the setOutput function to cover line 71
+    afterRunCall.data.setOutput(20);
+    expect(afterRunCall.data.output).toBe(20);
   });
 
   it("should handle errors and emit onError event", async () => {
@@ -137,4 +152,70 @@ describe("TaskRunner", () => {
       })
     );
   });
+
+  it("should handle error suppression", async () => {
+    const error = new Error("Test error");
+    const onErrorSpy = jest.fn().mockImplementation((event) => {
+      // Call suppress to cover line 113
+      event.data.suppress();
+    });
+
+    const task = defineTask({
+      id: "testTask",
+      run: async () => {
+        throw error;
+      },
+    });
+
+    store.tasks.set(task.id, {
+      task,
+      computedDependencies: {},
+      isInitialized: false,
+    });
+
+    eventManager.addListener(task.events.onError, onErrorSpy);
+
+    // The error should be suppressed, so no exception should be thrown
+    const result = await taskRunner.run(task, undefined);
+
+    expect(result).toBeUndefined();
+    expect(onErrorSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          error,
+          suppress: expect.any(Function),
+        }),
+      })
+    );
+  });
+
+  it("should handle global events and access output getter", async () => {
+    const globalAfterRunSpy = jest.fn();
+
+    const task = defineTask({
+      id: "testTask",
+      run: async (input: number) => input * 2,
+    });
+
+    store.tasks.set(task.id, {
+      task,
+      computedDependencies: {},
+      isInitialized: false,
+    });
+
+    // Listen to global afterRun event
+    eventManager.addListener(globalEvents.tasks.afterRun, globalAfterRunSpy);
+
+    await taskRunner.run(task, 5);
+
+    expect(globalAfterRunSpy).toHaveBeenCalledTimes(1);
+
+    // Access the output property to trigger the getter
+    const globalCall = globalAfterRunSpy.mock.calls[0][0];
+    expect(globalCall.data.output).toBe(10);
+
+    // Test setOutput function as well
+    globalCall.data.setOutput(25);
+    expect(globalCall.data.output).toBe(25);
+  });
 });