@ai.ntellect/core 0.6.1 → 0.6.3

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

@@ -1,465 +0,0 @@
-"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;
-        });
-    });
-});