@bluelibs/runner 1.0.0

package/src/__tests__/globalEvents.test.ts

@@ -0,0 +1,99 @@
+import { globalEvents } from "../globalEvents";
+import { defineTask, defineResource } from "../define";
+import { run } from "../run";
+
+describe("Global Events", () => {
+  it("should emit global events during resource initialization and task execution", async () => {
+    const globalBeforeInitHandler = jest.fn();
+    const globalAfterInitHandler = jest.fn();
+    const globalTaskBeforeRunHandler = jest.fn();
+    const globalTaskAfterRunHandler = jest.fn();
+    const globalResourceBeforeInitHandler = jest.fn();
+    const globalResourceAfterInitHandler = jest.fn();
+
+    const testResource = defineResource({
+      id: "test.resource",
+      init: async () => "Resource Value",
+    });
+
+    const testTask = defineTask({
+      id: "test.task",
+      run: async () => {
+        return "Task Result";
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [testResource, testTask],
+      dependencies: { testResource, testTask },
+      hooks: [
+        { event: globalEvents.beforeInit, run: globalBeforeInitHandler },
+        { event: globalEvents.afterInit, run: globalAfterInitHandler },
+        {
+          event: globalEvents.tasks.beforeRun,
+          run: globalTaskBeforeRunHandler,
+        },
+        {
+          event: globalEvents.tasks.afterRun,
+          run: globalTaskAfterRunHandler,
+        },
+        {
+          event: globalEvents.resources.beforeInit,
+          run: globalResourceBeforeInitHandler,
+        },
+        {
+          event: globalEvents.resources.afterInit,
+          run: globalResourceAfterInitHandler,
+        },
+      ],
+      async init(_, { testResource, testTask }) {
+        expect(testResource).toBe("Resource Value");
+        const response = await testTask();
+      },
+    });
+
+    await run(app);
+
+    expect(globalBeforeInitHandler).toHaveBeenCalled();
+    expect(globalAfterInitHandler).toHaveBeenCalled();
+    expect(globalResourceBeforeInitHandler).toHaveBeenCalled();
+    expect(globalResourceAfterInitHandler).toHaveBeenCalled();
+    expect(globalTaskBeforeRunHandler).toHaveBeenCalled();
+    expect(globalTaskAfterRunHandler).toHaveBeenCalled();
+  });
+
+  it("should emit global error event when an task throws an error", async () => {
+    const globalTaskOnErrorHandler = jest.fn();
+
+    const errorTask = defineTask({
+      id: "error.task",
+      run: async () => {
+        throw new Error("Test Error");
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [errorTask],
+      dependencies: { errorTask },
+      hooks: [
+        {
+          event: globalEvents.tasks.onError,
+          run: globalTaskOnErrorHandler,
+        },
+      ],
+      async init(_, { errorTask }) {
+        try {
+          await errorTask();
+        } catch (error) {
+          // Error is expected
+        }
+      },
+    });
+
+    await run(app);
+
+    expect(globalTaskOnErrorHandler).toHaveBeenCalled();
+  });
+});

package/src/__tests__/index.ts

@@ -0,0 +1,9 @@
+import "./EventManager.test";
+import "./tools/findCircularDependencies.test";
+import "./ResourceInitializer.test";
+import "./run.test";
+import "./run.hooks.test";
+import "./TaskRunner.test";
+import "./globalEvents.test";
+import "./Store.test";
+import "./errors.test";

package/src/__tests__/run.hooks.test.ts

@@ -0,0 +1,110 @@
+import {
+  defineTask,
+  defineResource,
+  defineEvent,
+  defineMiddleware,
+} from "../define";
+import { run } from "../run";
+
+describe("run", () => {
+  // Tasks
+  describe("Hooks", () => {
+    it("should work with hooks and beforeInit, afterInit, onError", async () => {
+      const beforeInitHandler = jest.fn();
+      const afterInitHandler = jest.fn();
+      const onErrorHandler = jest.fn();
+
+      const testResource = defineResource({
+        id: "test.resource",
+        init: async () => "Resource Value",
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [testResource],
+        dependencies: { testResource },
+        hooks: [
+          { event: testResource.events.beforeInit, run: beforeInitHandler },
+          { event: testResource.events.afterInit, run: afterInitHandler },
+          { event: testResource.events.onError, run: onErrorHandler },
+        ],
+        async init(_, { testResource }) {
+          expect(testResource).toBe("Resource Value");
+          expect(beforeInitHandler).toHaveBeenCalled();
+          expect(afterInitHandler).toHaveBeenCalled();
+          expect(onErrorHandler).not.toHaveBeenCalled();
+        },
+      });
+
+      await run(app);
+    });
+
+    it("should work with hooks() as function and config and beforeInit, afterInit, onError", async () => {
+      const beforeInitHandler = jest.fn();
+      const afterInitHandler = jest.fn();
+      const onErrorHandler = jest.fn();
+
+      const testResource = defineResource({
+        id: "test.resource",
+        init: async () => "Resource Value",
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [testResource],
+        dependencies: { testResource },
+        hooks: () => [
+          { event: testResource.events.beforeInit, run: beforeInitHandler },
+          { event: testResource.events.afterInit, run: afterInitHandler },
+          { event: testResource.events.onError, run: onErrorHandler },
+        ],
+        async init(_: { secret: string }, { testResource }) {
+          expect(testResource).toBe("Resource Value");
+          expect(_.secret).toBe("XXX");
+          expect(beforeInitHandler).toHaveBeenCalled();
+          expect(afterInitHandler).toHaveBeenCalled();
+          expect(onErrorHandler).not.toHaveBeenCalled();
+        },
+      });
+
+      const wrapper = defineResource({
+        id: "root",
+        register: [app.with({ secret: "XXX" })],
+      });
+
+      await run(wrapper);
+    });
+
+    it("should work with hooks", async () => {
+      const hookEvent = defineEvent<{ message: string }>({ id: "hook.event" });
+      const hookHandler = jest.fn();
+
+      const testResource = defineResource({
+        id: "test.resource",
+        init: async () => "Resource Value",
+        hooks: [
+          {
+            event: hookEvent,
+            run: hookHandler,
+          },
+        ],
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [hookEvent, testResource],
+        dependencies: { testResource, hookEvent },
+        async init(_, { testResource, hookEvent }) {
+          await hookEvent({ message: "Hook triggered" });
+
+          expect(hookHandler).toHaveBeenCalledWith(
+            expect.objectContaining({ data: { message: "Hook triggered" } }),
+            expect.anything()
+          );
+        },
+      });
+
+      await run(app);
+    });
+  });
+});