@ai.ntellect/core 0.5.0 → 0.6.0

package/dist/test/graph/engine.test.js

@@ -0,0 +1,465 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const engine_1 = require("@/graph/engine");
+const chai_1 = require("chai");
+const zod_1 = require("zod");
+/**
+ * Test suite for the Graph service
+ * This suite tests the workflow execution engine that manages state transitions and node execution
+ */
+describe("Graph", () => {
+    /**
+     * Test schema definition using Zod
+     * Defines the structure and validation rules for the workflow state
+     */
+    const TestSchema = zod_1.z.object({
+        status: zod_1.z.string(),
+        step: zod_1.z.number(),
+    });
+    let graph;
+    /**
+     * Test definition of a simple workflow graph
+     * Contains 3 nodes: start -> process -> end
+     * Each node updates the state with new status and step values
+     */
+    const testDefinition = {
+        name: "simple-workflow",
+        entryNode: "start",
+        nodes: {
+            start: {
+                name: "start",
+                description: "Starting node",
+                execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                    return graph.updateState({
+                        context: Object.assign(Object.assign({}, state.context), { status: "started", step: 1 }),
+                    });
+                }),
+                relationships: [{ name: "process" }],
+            },
+            process: {
+                name: "process",
+                description: "Processing node",
+                execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                    return graph.updateState({
+                        context: Object.assign(Object.assign({}, state.context), { status: "processing", step: 2 }),
+                    });
+                }),
+                condition: (state) => state.context.step === 1,
+                relationships: [{ name: "end" }],
+            },
+            end: {
+                name: "end",
+                description: "End node",
+                execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                    return graph.updateState({
+                        context: Object.assign(Object.assign({}, state.context), { status: "completed", step: 3 }),
+                    });
+                }),
+                relationships: [],
+            },
+        },
+        schema: TestSchema,
+    };
+    beforeEach(() => {
+        graph = new engine_1.GraphEngine(testDefinition);
+    });
+    describe("Workflow Execution", () => {
+        /**
+         * Tests the complete execution flow of the workflow
+         * Verifies that state transitions occur correctly from start to end
+         */
+        it("should execute the complete workflow sequence", () => __awaiter(void 0, void 0, void 0, function* () {
+            const initialState = {
+                context: {
+                    status: "init",
+                    step: 0,
+                },
+            };
+            // Initialiser le graph avec l'état initial
+            graph = new engine_1.GraphEngine(testDefinition, {
+                schema: TestSchema,
+                initialState,
+            });
+            // Exécuter le workflow
+            yield graph.execute(initialState, "start");
+            const result = graph.getState();
+            (0, chai_1.expect)(result.context).to.deep.equal({
+                status: "completed",
+                step: 3,
+            });
+        }));
+        /**
+         * Tests that conditional logic in nodes is respected
+         * The process node should only execute when step === 1
+         */
+        it("should respect conditions in workflow", () => __awaiter(void 0, void 0, void 0, function* () {
+            const initialState = {
+                context: {
+                    status: "init",
+                    step: 2,
+                },
+            };
+            // Initialiser le graph avec l'état initial
+            graph = new engine_1.GraphEngine(testDefinition, {
+                schema: TestSchema,
+                initialState,
+            });
+            yield graph.execute(initialState, "process");
+            const result = graph.getState();
+            (0, chai_1.expect)(result.context).to.deep.equal({
+                status: "init",
+                step: 2,
+            });
+        }));
+    });
+    describe("Graph Management", () => {
+        it("should add a new node to the graph", () => {
+            const newNode = {
+                name: "new-node",
+                description: "A new test node",
+                execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                    return graph.updateState({
+                        context: Object.assign(Object.assign({}, state.context), { status: "new", step: 4 }),
+                    });
+                }),
+            };
+            graph.addNode(newNode, {
+                relationships: [{ name: "end" }],
+            });
+            (0, chai_1.expect)(graph.nodes.has("new-node")).to.be.true;
+            const addedNode = graph.nodes.get("new-node");
+            (0, chai_1.expect)(addedNode === null || addedNode === void 0 ? void 0 : addedNode.relationships).to.have.lengthOf(1);
+        });
+        it("should update existing graph with new definition", () => {
+            const newDefinition = {
+                name: "updated-workflow",
+                entryNode: "start",
+                nodes: Object.assign(Object.assign({}, testDefinition.nodes), { "new-step": {
+                        name: "new-step",
+                        description: "New step node",
+                        execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                            return graph.updateState({
+                                context: Object.assign(Object.assign({}, state.context), { status: "new-step", step: 4 }),
+                            });
+                        }),
+                        relationships: [],
+                    } }),
+                schema: TestSchema,
+            };
+            graph.updateGraph(newDefinition);
+            (0, chai_1.expect)(graph.nodes.has("new-step")).to.be.true;
+        });
+    });
+    describe("State Management", () => {
+        it("should properly update and retrieve state", () => __awaiter(void 0, void 0, void 0, function* () {
+            const newState = {
+                context: {
+                    status: "test",
+                    step: 5,
+                },
+            };
+            graph.setState(newState);
+            const retrievedState = graph.getState();
+            (0, chai_1.expect)(retrievedState.context).to.deep.equal(newState.context);
+        }));
+        it("should merge states correctly when updating partially", () => {
+            const initialState = {
+                context: {
+                    status: "initial",
+                    step: 1,
+                },
+            };
+            graph.setState(initialState);
+            const partialUpdate = {
+                context: {
+                    status: "updated",
+                },
+            };
+            const updatedState = graph.updateState(partialUpdate);
+            (0, chai_1.expect)(updatedState.context).to.deep.equal({
+                status: "updated",
+                step: 1,
+            });
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle execution errors gracefully", () => __awaiter(void 0, void 0, void 0, function* () {
+            const errorNode = {
+                name: "error-node",
+                execute: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error("Test error");
+                }),
+            };
+            graph.addNode(errorNode, {});
+            let errorCaught = false;
+            try {
+                yield graph.execute({ context: { status: "test", step: 1 } }, "error-node", undefined, (error) => {
+                    (0, chai_1.expect)(error.message).to.equal("Test error");
+                    errorCaught = true;
+                });
+            }
+            catch (error) {
+                (0, chai_1.expect)(error).to.be.instanceOf(Error);
+                (0, chai_1.expect)(error.message).to.equal("Test error");
+            }
+            (0, chai_1.expect)(errorCaught).to.be.true;
+        }));
+        it("should validate state against schema", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Créer un nouveau graph avec validation stricte
+            const strictGraph = new engine_1.GraphEngine(testDefinition, {
+                schema: TestSchema,
+                initialState: {
+                    context: {
+                        status: "init",
+                        step: 0,
+                    },
+                },
+            });
+            const invalidState = {
+                context: {
+                    status: 123, // Should be string
+                    step: "invalid", // Should be number
+                },
+            };
+            try {
+                yield strictGraph.execute(invalidState, "start");
+                // Si on arrive ici, le test doit échouer car on s'attend à une erreur
+                chai_1.expect.fail("Expected validation error but none was thrown");
+            }
+            catch (error) {
+                (0, chai_1.expect)(error).to.be.instanceOf(Error);
+                const errorMessage = error.message;
+                (0, chai_1.expect)(errorMessage.includes("Expected string") ||
+                    errorMessage.includes("Expected number") ||
+                    errorMessage.includes("validation")).to.be.true;
+            }
+        }));
+    });
+    describe("Parallel Execution", () => {
+        /**
+         * Tests concurrent execution of multiple nodes
+         * Important: The execution order is not guaranteed due to async nature
+         * @param concurrency - Maximum number of nodes that can execute simultaneously
+         */
+        it("should execute multiple nodes in parallel", () => __awaiter(void 0, void 0, void 0, function* () {
+            const executionOrder = [];
+            const parallelNodes = ["node1", "node2", "node3"].map((name) => ({
+                name,
+                execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                    executionOrder.push(name);
+                    yield new Promise((resolve) => setTimeout(resolve, 10));
+                    return state;
+                }),
+            }));
+            parallelNodes.forEach((node) => {
+                graph.addNode(node, {});
+            });
+            yield graph.executeParallel({ context: { status: "test", step: 1 } }, ["node1", "node2", "node3"], 2);
+            (0, chai_1.expect)(executionOrder).to.have.lengthOf(3);
+            (0, chai_1.expect)(executionOrder).to.include.members(["node1", "node2", "node3"]);
+        }));
+    });
+    describe("Event Handling", () => {
+        /**
+         * Tests the event emission and handling system
+         * Events can trigger node execution asynchronously
+         * Note: Uses setTimeout to ensure event processing completes
+         */
+        it("should emit and handle events correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+            const eventNode = {
+                name: "event-node",
+                execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                    return graph.updateState({
+                        context: Object.assign(Object.assign({}, state.context), { status: "event-triggered", step: 10 }),
+                    });
+                }),
+                events: ["test-event"],
+            };
+            graph.addNode(eventNode, { events: ["test-event"] });
+            // Émettre l'événement
+            graph.emit("test-event", {
+                state: { context: { status: "init", step: 0 } },
+            });
+            // Attendre un peu pour que l'événement soit traité
+            yield new Promise((resolve) => setTimeout(resolve, 50));
+            const state = graph.getState();
+            (0, chai_1.expect)(state.context.status).to.equal("event-triggered");
+            (0, chai_1.expect)(state.context.status).to.equal("event-triggered");
+        }));
+    });
+    describe("Subgraph Integration", () => {
+        /**
+         * Tests nested workflow execution through subgraphs
+         * Subgraphs allow modular workflow composition
+         * The main graph can delegate execution to subgraphs
+         */
+        it("should execute subgraph as part of main graph", () => __awaiter(void 0, void 0, void 0, function* () {
+            const subGraphDef = {
+                name: "sub-workflow",
+                entryNode: "sub-start",
+                nodes: {
+                    "sub-start": {
+                        name: "sub-start",
+                        execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                            return graph.updateState({
+                                context: Object.assign(Object.assign({}, state.context), { status: "sub-completed", step: 100 }),
+                            });
+                        }),
+                        relationships: [],
+                    },
+                },
+                schema: TestSchema,
+            };
+            const subGraph = new engine_1.GraphEngine(subGraphDef);
+            graph.addSubGraph(subGraph, "sub-start", "sub-workflow");
+            const initialState = {
+                context: {
+                    status: "init",
+                    step: 0,
+                },
+            };
+            yield graph.execute(initialState, "sub-workflow");
+            const state = graph.getState();
+            (0, chai_1.expect)(state.context.status).to.equal("sub-completed");
+            (0, chai_1.expect)(state.context.step).to.equal(100);
+        }));
+    });
+    describe("Global Context Management", () => {
+        it("should manage global context correctly", () => {
+            graph.addToContext("testKey", "testValue");
+            (0, chai_1.expect)(graph.getContext("testKey")).to.equal("testValue");
+            graph.removeFromContext("testKey");
+            (0, chai_1.expect)(graph.getContext("testKey")).to.be.undefined;
+        });
+        it("should handle multiple context values", () => {
+            graph.addToContext("key1", "value1");
+            graph.addToContext("key2", { nested: "value2" });
+            (0, chai_1.expect)(graph.getContext("key1")).to.equal("value1");
+            (0, chai_1.expect)(graph.getContext("key2")).to.deep.equal({ nested: "value2" });
+        });
+    });
+    describe("Graph Visualization", () => {
+        it("should generate valid mermaid diagram", () => {
+            const diagram = graph.generateMermaidDiagram("Test Workflow");
+            (0, chai_1.expect)(diagram).to.include("flowchart TD");
+            (0, chai_1.expect)(diagram).to.include("subgraph Test Workflow");
+            (0, chai_1.expect)(diagram).to.include("start");
+            (0, chai_1.expect)(diagram).to.include("process");
+            (0, chai_1.expect)(diagram).to.include("end");
+        });
+    });
+    describe("Schema Visualization", () => {
+        /**
+         * Tests the schema visualization functionality
+         * This helps developers understand the workflow structure
+         * The visualization includes:
+         * - Node relationships
+         * - State schema
+         * - Validation rules
+         */
+        it("should generate schema visualization", () => {
+            // Créer un nouveau graph avec un schéma pour le test
+            const graphWithSchema = new engine_1.GraphEngine(testDefinition, {
+                schema: TestSchema,
+            });
+            const schemaVisualization = graphWithSchema.visualizeSchema();
+            // Vérifier les sections attendues dans la visualisation
+            (0, chai_1.expect)(schemaVisualization).to.include("📋 Graph:");
+            (0, chai_1.expect)(schemaVisualization).to.include("🔷 Nodes:");
+            // Vérifier les détails du schéma
+            (0, chai_1.expect)(schemaVisualization).to.satisfy((text) => {
+                return text.includes("status:") && text.includes("step:");
+            });
+            // Vérifier la présence des nœuds
+            (0, chai_1.expect)(schemaVisualization).to.include("start");
+            (0, chai_1.expect)(schemaVisualization).to.include("process");
+            (0, chai_1.expect)(schemaVisualization).to.include("end");
+        });
+    });
+    describe("Persistence Integration", () => {
+        it("should work with persistence layer", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockPersistence = {
+                saveState: (graphName, state, currentNode) => __awaiter(void 0, void 0, void 0, function* () {
+                    (0, chai_1.expect)(graphName).to.equal("simple-workflow");
+                    (0, chai_1.expect)(state.context).to.exist;
+                    (0, chai_1.expect)(currentNode).to.exist;
+                }),
+                loadState: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+            };
+            graph.setPersistence(mockPersistence);
+            yield graph.execute({ context: { status: "init", step: 0 } }, "start");
+        }));
+    });
+    describe("Real-time Notifications", () => {
+        /**
+         * Tests the notification system during workflow execution
+         * Notifications are sent for:
+         * - Node execution start
+         * - Node execution completion
+         * - State updates
+         * - Error events
+         */
+        it("should send notifications during execution", () => __awaiter(void 0, void 0, void 0, function* () {
+            const notifications = [];
+            const mockNotifier = {
+                notify: (event, data) => {
+                    notifications.push({ event, data });
+                },
+            };
+            graph.setNotifier(mockNotifier);
+            yield graph.execute({ context: { status: "init", step: 0 } }, "start");
+            (0, chai_1.expect)(notifications).to.have.length.greaterThan(0);
+            (0, chai_1.expect)(notifications[0].event).to.equal("nodeExecutionStarted");
+            (0, chai_1.expect)(notifications).to.deep.include.members([
+                {
+                    event: "nodeExecutionCompleted",
+                    data: {
+                        workflow: "simple-workflow",
+                        node: "start",
+                        state: {
+                            context: {
+                                status: "started",
+                                step: 1,
+                            },
+                        },
+                    },
+                },
+            ]);
+        }));
+    });
+    describe("Cycle Detection", () => {
+        /**
+         * Tests the cycle detection mechanism
+         * Cycles in workflow definitions can cause infinite loops
+         * The graph constructor should detect and prevent cyclic dependencies
+         */
+        it("should detect cycles in graph", () => {
+            const cyclicDefinition = {
+                name: "cyclic-workflow",
+                entryNode: "node1",
+                nodes: {
+                    node1: {
+                        name: "node1",
+                        execute: (state) => __awaiter(void 0, void 0, void 0, function* () { return state; }),
+                        relationships: [{ name: "node2" }],
+                    },
+                    node2: {
+                        name: "node2",
+                        execute: (state) => __awaiter(void 0, void 0, void 0, function* () { return state; }),
+                        relationships: [{ name: "node1" }],
+                    },
+                },
+            };
+            (0, chai_1.expect)(() => new engine_1.GraphEngine(cyclicDefinition, { autoDetectCycles: true })).to.throw;
+        });
+    });
+});