@bluelibs/runner 3.4.2 → 4.0.1

package/src/__tests__/tools/findCircularDependencies.test.ts

@@ -1,217 +0,0 @@
-import {
-  findCircularDependencies,
-  IDependentNode,
-} from "../../tools/findCircularDependencies";
-
-describe("checkCircularDependencies", () => {
-  test("should detect a simple cycle (A -> B -> C -> A)", () => {
-    const nodeA: IDependentNode = { id: "A", dependencies: {} };
-    const nodeB: IDependentNode = { id: "B", dependencies: {} };
-    const nodeC: IDependentNode = { id: "C", dependencies: {} };
-
-    nodeA.dependencies["B"] = nodeB;
-    nodeB.dependencies["C"] = nodeC;
-    nodeC.dependencies["A"] = nodeA;
-
-    const nodes: IDependentNode[] = [nodeA, nodeB, nodeC];
-    const result = findCircularDependencies(nodes);
-
-    expect(result.cycles).toEqual(["A -> B -> C -> A"]);
-    expect(result.missingDependencies).toEqual([]);
-  });
-
-  test("should detect multiple cycles", () => {
-    const nodeA: IDependentNode = { id: "A", dependencies: {} };
-    const nodeB: IDependentNode = { id: "B", dependencies: {} };
-    const nodeC: IDependentNode = { id: "C", dependencies: {} };
-    const nodeD: IDependentNode = { id: "D", dependencies: {} };
-
-    nodeA.dependencies["B"] = nodeB;
-    nodeB.dependencies["C"] = nodeC;
-    nodeC.dependencies["A"] = nodeA; // Cycle: A -> B -> C -> A
-    nodeC.dependencies["D"] = nodeD;
-    nodeD.dependencies["B"] = nodeB; // Cycle: B -> C -> D -> B
-
-    const nodes: IDependentNode[] = [nodeA, nodeB, nodeC, nodeD];
-    const result = findCircularDependencies(nodes);
-
-    // The order of cycles in the result array might vary
-    expect(result.cycles).toContain("A -> B -> C -> A");
-    expect(result.cycles).toContain("B -> C -> D -> B");
-    expect(result.cycles.length).toBe(2);
-    expect(result.missingDependencies).toEqual([]);
-  });
-
-  test("should return empty arrays when there are no cycles", () => {
-    const nodeA: IDependentNode = { id: "A", dependencies: {} };
-    const nodeB: IDependentNode = { id: "B", dependencies: {} };
-    const nodeC: IDependentNode = { id: "C", dependencies: {} };
-
-    nodeA.dependencies["B"] = nodeB;
-    nodeB.dependencies["C"] = nodeC;
-
-    const nodes: IDependentNode[] = [nodeA, nodeB, nodeC];
-    const result = findCircularDependencies(nodes);
-
-    expect(result.cycles).toEqual([]);
-    expect(result.missingDependencies).toEqual([]);
-  });
-
-  test("should detect a self-referential cycle (A -> A)", () => {
-    const nodeA: IDependentNode = { id: "A", dependencies: {} };
-    nodeA.dependencies["A"] = nodeA; // Cycle: A -> A
-
-    const nodes: IDependentNode[] = [nodeA];
-    const result = findCircularDependencies(nodes);
-
-    expect(result.cycles).toEqual(["A -> A"]);
-    expect(result.missingDependencies).toEqual([]);
-  });
-
-  test("should handle complex graphs with shared nodes", () => {
-    const nodeA: IDependentNode = { id: "A", dependencies: {} };
-    const nodeB: IDependentNode = { id: "B", dependencies: {} };
-    const nodeC: IDependentNode = { id: "C", dependencies: {} };
-    const nodeD: IDependentNode = { id: "D", dependencies: {} };
-    const nodeE: IDependentNode = { id: "E", dependencies: {} };
-
-    nodeA.dependencies["B"] = nodeB;
-    nodeB.dependencies["C"] = nodeC;
-    nodeC.dependencies["D"] = nodeD;
-    nodeD.dependencies["B"] = nodeB; // Cycle: B -> C -> D -> B
-    nodeC.dependencies["E"] = nodeE;
-    nodeE.dependencies["C"] = nodeC; // Cycle: C -> E -> C
-
-    const nodes: IDependentNode[] = [nodeA, nodeB, nodeC, nodeD, nodeE];
-    const result = findCircularDependencies(nodes);
-
-    expect(result.cycles).toContain("B -> C -> D -> B");
-    expect(result.cycles).toContain("C -> E -> C");
-    expect(result.cycles.length).toBe(2);
-    expect(result.missingDependencies).toEqual([]);
-  });
-
-  test("should handle multiple independent cycles", () => {
-    const nodeA: IDependentNode = { id: "A", dependencies: {} };
-    const nodeB: IDependentNode = { id: "B", dependencies: {} };
-    const nodeC: IDependentNode = { id: "C", dependencies: {} };
-    const nodeD: IDependentNode = { id: "D", dependencies: {} };
-    const nodeE: IDependentNode = { id: "E", dependencies: {} };
-    const nodeF: IDependentNode = { id: "F", dependencies: {} };
-
-    // Cycle 1: A -> B -> A
-    nodeA.dependencies["B"] = nodeB;
-    nodeB.dependencies["A"] = nodeA;
-
-    // Cycle 2: C -> D -> E -> C
-    nodeC.dependencies["D"] = nodeD;
-    nodeD.dependencies["E"] = nodeE;
-    nodeE.dependencies["C"] = nodeC;
-
-    // Cycle 3: F -> F
-    nodeF.dependencies["F"] = nodeF;
-
-    const nodes: IDependentNode[] = [nodeA, nodeB, nodeC, nodeD, nodeE, nodeF];
-    const result = findCircularDependencies(nodes);
-
-    expect(result.cycles).toContain("A -> B -> A");
-    expect(result.cycles).toContain("C -> D -> E -> C");
-    expect(result.cycles).toContain("F -> F");
-    expect(result.cycles.length).toBe(3);
-    expect(result.missingDependencies).toEqual([]);
-  });
-
-  test("should handle disconnected graphs", () => {
-    const nodeA: IDependentNode = { id: "A", dependencies: {} };
-    const nodeB: IDependentNode = { id: "B", dependencies: {} };
-    const nodeC: IDependentNode = { id: "C", dependencies: {} };
-    const nodeD: IDependentNode = { id: "D", dependencies: {} };
-
-    // Cycle 1: A -> B -> A
-    nodeA.dependencies["B"] = nodeB;
-    nodeB.dependencies["A"] = nodeA;
-
-    // Cycle 2: C -> D -> C
-    nodeC.dependencies["D"] = nodeD;
-    nodeD.dependencies["C"] = nodeC;
-
-    const nodes: IDependentNode[] = [nodeA, nodeB, nodeC, nodeD];
-    const result = findCircularDependencies(nodes);
-
-    expect(result.cycles).toContain("A -> B -> A");
-    expect(result.cycles).toContain("C -> D -> C");
-    expect(result.cycles.length).toBe(2);
-    expect(result.missingDependencies).toEqual([]);
-  });
-
-  test("should handle nodes with no dependencies", () => {
-    const nodeA: IDependentNode = { id: "A", dependencies: {} };
-    const nodeB: IDependentNode = { id: "B", dependencies: {} };
-
-    const nodes: IDependentNode[] = [nodeA, nodeB];
-    const result = findCircularDependencies(nodes);
-
-    expect(result.cycles).toEqual([]);
-    expect(result.missingDependencies).toEqual([]);
-  });
-
-  test("should handle dependencies that do not form cycles", () => {
-    const nodeA: IDependentNode = { id: "A", dependencies: {} };
-    const nodeB: IDependentNode = { id: "B", dependencies: {} };
-    const nodeC: IDependentNode = { id: "C", dependencies: {} };
-    const nodeD: IDependentNode = { id: "D", dependencies: {} };
-
-    nodeA.dependencies["B"] = nodeB;
-    nodeB.dependencies["C"] = nodeC;
-    nodeC.dependencies["D"] = nodeD;
-
-    const nodes: IDependentNode[] = [nodeA, nodeB, nodeC, nodeD];
-    const result = findCircularDependencies(nodes);
-
-    expect(result.cycles).toEqual([]);
-    expect(result.missingDependencies).toEqual([]);
-  });
-
-  test("should report missing dependencies", () => {
-    const nodeA: IDependentNode = { id: "A", dependencies: {} };
-    // nodeB is missing
-    nodeA.dependencies["B"] = undefined as any; // Force undefined dependency
-
-    const nodes: IDependentNode[] = [nodeA];
-    const result = findCircularDependencies(nodes);
-
-    expect(result.cycles).toEqual([]);
-    expect(result.missingDependencies).toEqual([
-      { nodeId: "A", dependencyId: "B" },
-    ]);
-  });
-
-  test("should handle complex graph with multiple overlapping cycles", () => {
-    const nodeA: IDependentNode = { id: "A", dependencies: {} };
-    const nodeB: IDependentNode = { id: "B", dependencies: {} };
-    const nodeC: IDependentNode = { id: "C", dependencies: {} };
-    const nodeD: IDependentNode = { id: "D", dependencies: {} };
-    const nodeE: IDependentNode = { id: "E", dependencies: {} };
-    const nodeF: IDependentNode = { id: "F", dependencies: {} };
-
-    // Construct cycles:
-    // A -> B -> C -> A
-    // C -> D -> E -> F -> C
-
-    nodeA.dependencies["B"] = nodeB;
-    nodeB.dependencies["C"] = nodeC;
-    nodeC.dependencies["A"] = nodeA;
-    nodeC.dependencies["D"] = nodeD;
-    nodeD.dependencies["E"] = nodeE;
-    nodeE.dependencies["F"] = nodeF;
-    nodeF.dependencies["C"] = nodeC;
-
-    const nodes: IDependentNode[] = [nodeA, nodeB, nodeC, nodeD, nodeE, nodeF];
-    const result = findCircularDependencies(nodes);
-
-    expect(result.cycles).toContain("A -> B -> C -> A");
-    expect(result.cycles).toContain("C -> D -> E -> F -> C");
-    expect(result.cycles.length).toBe(2);
-    expect(result.missingDependencies).toEqual([]);
-  });
-});

package/src/__tests__/tools/getCallerFile.test.ts

@@ -1,179 +0,0 @@
-import {
-  defineTask,
-  defineResource,
-  defineMiddleware,
-  defineEvent,
-} from "../../define";
-import { symbolFilePath } from "../../defs";
-import {
-  getCallerFile,
-  generateCallerIdFromFile,
-} from "../../tools/getCallerFile";
-
-describe("getCallerFile", () => {
-  it("should return the file name of the caller", () => {
-    function testFunction() {
-      return getCallerFile();
-    }
-
-    const callerFile = testFunction();
-
-    expect(callerFile).toBeDefined();
-    expect(callerFile).toContain("getCallerFile.test"); // we don't use .ts because for coverage it gets compiled to js
-  });
-
-  it("Should work with tasks, resources, middleware and events", () => {
-    const task = defineTask({
-      id: "task",
-      run: async () => {},
-    });
-    const resource = defineResource({
-      id: "resource",
-      init: async () => {},
-    });
-
-    const middleware = defineMiddleware({
-      id: "middleware",
-      run: async () => {},
-    });
-
-    const event = defineEvent({
-      id: "event",
-    });
-
-    expect((task as any)[symbolFilePath]).toBeDefined();
-    expect((resource as any)[symbolFilePath]).toBeDefined();
-    expect((middleware as any)[symbolFilePath]).toBeDefined();
-    expect((event as any)[symbolFilePath]).toBeDefined();
-
-    expect((task as any)[symbolFilePath]).toContain("getCallerFile.test");
-    expect((resource as any)[symbolFilePath]).toContain("getCallerFile.test");
-    expect((middleware as any)[symbolFilePath]).toContain("getCallerFile.test");
-    expect((event as any)[symbolFilePath]).toContain("getCallerFile.test");
-  });
-});
-
-describe("generateCallerIdFromFile", () => {
-  it("should generate a symbol from a path containing src", () => {
-    const filePath =
-      "/Users/theodordiaconu/Projects/runner/src/globals/resources/queue.resource.ts";
-    const expectedDescription = "src.globals.resources.queue.resource";
-    expect(generateCallerIdFromFile(filePath).description).toEqual(
-      expectedDescription
-    );
-  });
-
-  it("should generate a symbol from a path not containing src", () => {
-    const filePath =
-      "/Users/theodordiaconu/Projects/runner/dist/globals/resources/queue.resource.ts";
-    const expectedDescription = "dist.globals.resources.queue.resource";
-    expect(generateCallerIdFromFile(filePath).description).toEqual(
-      expectedDescription
-    );
-  });
-
-  it("should handle paths with few parts when src is not present", () => {
-    const filePath = "a/b/c.ts";
-    const expectedDescription = "a.b.c";
-    expect(generateCallerIdFromFile(filePath).description).toEqual(
-      expectedDescription
-    );
-  });
-
-  it("should handle paths with backslashes", () => {
-    const filePath =
-      "C:\\Users\\theodordiaconu\\Projects\\runner\\src\\globals\\resources\\queue.resource.ts";
-    const expectedDescription = "src.globals.resources.queue.resource";
-    expect(generateCallerIdFromFile(filePath).description).toEqual(
-      expectedDescription
-    );
-  });
-
-  it("should handle file names without extensions", () => {
-    const filePath =
-      "/Users/theodordiaconu/Projects/runner/src/globals/resources/queue.resource";
-    const expectedDescription = "src.globals.resources.queue.resource";
-    expect(generateCallerIdFromFile(filePath).description).toEqual(
-      expectedDescription
-    );
-  });
-
-  it("should handle file names with multiple dots", () => {
-    const filePath =
-      "/Users/theodordiaconu/Projects/runner/src/globals/resources/queue.resource.test.ts";
-    const expectedDescription = "src.globals.resources.queue.resource.test";
-    expect(generateCallerIdFromFile(filePath).description).toEqual(
-      expectedDescription
-    );
-  });
-
-  it("should generate a symbol from a path containing node_modules", () => {
-    const filePath =
-      "/Users/theodordiaconu/Projects/runner/node_modules/some-package/dist/index.js";
-    const expectedDescription = "some-package.dist.index";
-    expect(generateCallerIdFromFile(filePath).description).toEqual(
-      expectedDescription
-    );
-  });
-
-  it("should respect the fallbackParts argument", () => {
-    const filePath = "a/b/c/d/e.ts";
-    const expectedDescription = "d.e";
-    expect(generateCallerIdFromFile(filePath, "", 2).description).toEqual(
-      expectedDescription
-    );
-  });
-
-  it("should append the suffix to the symbol description", () => {
-    const filePath = "a/b/c.ts";
-    const expectedDescription = "a.b.c.my-suffix";
-    expect(generateCallerIdFromFile(filePath, "my-suffix").description).toEqual(
-      expectedDescription
-    );
-  });
-
-  it("should not append the suffix if it is already in the file name", () => {
-    const filePath = "a/b/c.resource.ts";
-    const expectedDescription = "a.b.c.resource";
-    expect(generateCallerIdFromFile(filePath, "resource").description).toEqual(
-      expectedDescription
-    );
-  });
-
-  it("should handle empty path or path with no relevant parts", () => {
-    // Test with empty string - this creates relevantParts = [""] which is not empty
-    const filePath = "";
-    const expectedDescription = ".suffix";
-    expect(generateCallerIdFromFile(filePath, "suffix").description).toEqual(
-      expectedDescription
-    );
-
-    // Test case where 'src' is at the end, making relevantParts empty (triggers line 77 else branch)
-    const result = generateCallerIdFromFile("/some/path/src", "suffix");
-    expect(result.description).toEqual(".some.path.src.suffix");
-  });
-
-  it("should use fallback parts when no src or node_modules found", () => {
-    // Test path without src or node_modules to trigger the else branch (line 59)
-    const filePath = "/some/other/deep/path/file.js";
-    const expectedDescription = "other.deep.path.file";
-    expect(generateCallerIdFromFile(filePath, "", 4).description).toEqual(
-      expectedDescription
-    );
-  });
-
-  it("should handle path equal to process.cwd() (relative root)", () => {
-    const expectedDescription = ".suffix";
-    expect(
-      generateCallerIdFromFile(process.cwd(), "suffix").description
-    ).toEqual(expectedDescription);
-  });
-
-  it("should handle path ending with node_modules (no relevant parts)", () => {
-    const path = `${process.cwd()}/node_modules`;
-    const expectedDescription = ".suffix";
-    expect(generateCallerIdFromFile(path, "suffix").description).toEqual(
-      expectedDescription
-    );
-  });
-});