data-primals-engine 1.0.8 → 1.0.10

package/test/workflow.integration.test.js

@@ -0,0 +1,314 @@
+// __tests__/workflow.integration.test.js
+import { expect, describe, it, beforeEach,afterEach, beforeAll, afterAll, vi } from 'vitest';
+import { Config } from "data-primals-engine/config";
+
+import {insertData, editData, deleteData, patchData} from 'data-primals-engine/modules/data';
+import { modelsCollection as getAppModelsCollection, getCollectionForUser } from 'data-primals-engine/modules/mongodb';
+import * as workflowModule from 'data-primals-engine/modules/workflow';
+import {getUniquePort, initEngine} from "../src/setenv.js";
+import process from "process";
+
+
+beforeAll(async () =>{
+    Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
+    await initEngine();
+})
+vi.mock('data-primals-engine/modules/workflow', { spy: true })
+// --- Données Mock pour les tests ---
+const mockUser = {
+    username: 'testuserWorkflow',
+    _user: 'testuserWorkflow',
+    userPlan: 'free',
+    email: 'testWorkflow@example.com'
+};
+
+// --- Définitions des modèles ---
+
+// Le modèle de données qui déclenchera les workflows
+const targetDataModel = {
+    name: 'project',
+    _user: mockUser.username,
+    description: 'Un modèle pour les projets qui déclencheront des workflows',
+    fields: [
+        { name: 'projectName', type: 'string', required: true },
+        { name: 'status', type: 'string', required: true }, // ex: 'new', 'active', 'archived'
+        { name: 'budget', type: 'number' }
+    ],
+};
+
+// Les modèles qui définissent le système de workflow lui-même.
+// Pour les tests, nous devons insérer leurs définitions dans la collection 'models',
+// puis leurs instances (ex: un trigger spécifique) dans la collection 'datas' de l'utilisateur.
+// Les modèles qui définissent le système de workflow lui-me.
+// Pour les tests, nous devons insérer leurs définitions dans la collection 'models',
+// puis leurs instances (ex: un trigger spécifique) dans la collection 'datas' de l'utilisateur.
+const workflowMetaModels = [
+    {
+        name: 'workflow',
+        _user: mockUser.username,
+        description:'',
+        fields: [
+            { name: 'name', type: 'string' },
+            { name: 'startStep', type: 'relation', relation: 'workflowStep' }
+        ]
+    },
+    {
+        name: 'workflowStep',
+        _user: mockUser.username,
+        description:'',
+        fields: [
+            { name: 'name', type: 'string' },
+            { name: 'onSuccessStep', type: 'relation', relation: 'workflowStep' },
+            { name: 'onFailureStep', type: 'relation', relation: 'workflowStep' },
+            { name: 'isTerminal', type: 'boolean' },
+            { name: 'actions', type: 'array', itemsType: 'relation', relation: 'workflowAction' },
+            { name: 'conditions', type: 'object' }
+        ]
+    },
+    {
+        name: 'workflowTrigger',
+        _user: mockUser.username,
+        description:'',
+        fields: [
+            { name: 'name', type: 'string' },
+            { name: 'targetModel', type: 'model' },
+            { name: 'onEvent', type: 'enum', items: ['DataAdded', 'DataEdited', 'DataDeleted', 'ModelAdded', 'ModelEdited', 'ModelDeleted'] },
+            { name: 'isActive', type: 'boolean' },
+            { name: 'dataFilter', type: 'object' },
+            { name: 'workflow', type: 'relation', relation: 'workflow' },
+            { name: 'cronExpression', type: 'cronSchedule' },
+            { name: 'lockDurationMinutes', type: 'number' }
+        ]
+    },
+    {
+        name: 'workflowRun',
+        _user: mockUser.username,
+        description:'',
+        fields: [
+            { name: 'status', type: 'enum', items: ['pending', 'running', 'completed', 'failed', 'cancelled'] },
+            { name: 'workflow', type: 'relation', relation: 'workflow' },
+            { name: 'contextData', type: 'object' },
+            { name: 'currentStep', type: 'relation', relation: 'workflowStep' },
+            { name: 'error', type: 'string' },
+            { name: 'startedAt', type: 'datetime' },
+            { name: 'completedAt', type: 'datetime' },
+            { name: 'stepExecutionsCount', type: 'object' }
+        ]
+    },
+    {
+        name: 'workflowAction',
+        _user: mockUser.username,
+        description:'',
+        fields: [
+            // Common
+            { name: 'name', type: 'string' },
+            { name: 'type', type: 'enum', items: ['Webhook', 'CreateData', 'UpdateData', 'DeleteData', 'GenerateAIContent', 'SendEmail'] },
+            // Webhook
+            { name: 'url', type: 'url' },
+            { name: 'method', type: 'enum', items: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'] },
+            { name: 'headers', type: 'code', language: 'json' },
+            { name: 'body', type: 'code', language: 'json' },
+            // Create/Update/Delete
+            { name: 'targetModel', type: 'model' },
+            { name: 'dataToCreate', type: 'code', language: 'json' },
+            { name: 'targetSelector', type: 'code', language: 'json' },
+            { name: 'fieldsToUpdate', type: 'code', language: 'json' },
+            { name: 'updateMultiple', type: 'boolean' },
+            { name: 'deleteMultiple', type: 'boolean' },
+            // GenerateAIContent
+            { name: 'aiProvider', type: 'enum', items: ['OpenAI', 'GoogleGemini'] },
+            { name: 'aiModel', type: 'string' },
+            { name: 'prompt', type: 'richtext' },
+            // SendEmail
+            { name: 'emailRecipients', type: 'array', itemsType: 'string' },
+            { name: 'emailSubject', type: 'string' },
+            { name: 'emailContent', type: 'richtext' }
+        ]
+    }
+];
+
+
+let testModelsColInstance;
+let testDatasColInstance;
+let engineInstance;
+
+const port = process.env.PORT || getUniquePort(); // Port différent
+
+// On "espionne" `c` pour vérifier qu'elle est appelée sans l'exécuter réellement.
+// Cela nous permet de tester uniquement la logique de déclenchement.
+const processWorkflowRunSpy = vi.spyOn(workflowModule, 'processWorkflowRun');
+
+beforeEach(async () => {
+    testModelsColInstance = getAppModelsCollection;
+    testDatasColInstance = getCollectionForUser(mockUser);
+    // Nettoyer les données avant chaque test
+    await testDatasColInstance.deleteMany({_user: "testuserWorkflow"});
+
+    // Réinitialiser l'espion
+    processWorkflowRunSpy.mockClear();
+
+    const mods = await testModelsColInstance.find({ $and: [{ _user: mockUser.username}, { $or: [{name: targetDataModel.name}, ...workflowMetaModels.map(m =>({name: m.name}))]}]}).toArray();
+    if( mods.length === 0 ) {
+        // Insérer les définitions de modèles nécessaires
+        await testModelsColInstance.insertMany([
+            {...targetDataModel},
+            ...workflowMetaModels.map(m => ({...m})) // Copie pour éviter les mutations
+        ]);
+    }
+    console.log({mods})
+});
+
+describe('Intégration des Workflows - triggerWorkflows', () => {
+
+    let testWorkflow;
+    let testStep;
+
+    // Avant chaque test de ce bloc, on crée un workflow et une étape de base
+    const initTest = async () => {
+        const workflowInsertResult = await insertData('workflow', { name: 'Test Workflow' }, {}, mockUser, false);
+        testWorkflow = { _id: workflowInsertResult.insertedIds[0] };
+
+        const stepInsertResult = await insertData('workflowStep', { name: 'Start Step', isTerminal: true }, {}, mockUser, false);
+        testStep = { _id: stepInsertResult.insertedIds[0] };
+
+        // Lier l'étape au workflow
+        await editData('workflow', testWorkflow._id, { startStep: testStep._id.toString() }, {}, mockUser, false);
+    };
+
+    it('devrait créer un workflowRun lors de l\'ajout de données correspondant à un trigger "DataAdded"', async () => {
+        await initTest();
+        // 1. Arrange: Créer un déclencheur actif pour 'DataAdded' sur le modèle 'project'
+        await insertData('workflowTrigger', {
+            name: 'Trigger on Project Add',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataAdded',
+            isActive: true,
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Insérer une donnée qui doit déclencher le workflow
+        const projectData = { projectName: 'New Corp Website', status: 'new', budget: 50000 };
+        const insertResult = await insertData(targetDataModel.name, projectData, {}, mockUser, true, true);
+
+        expect(insertResult.success).toBe(true);
+
+        const workflowRun = await testDatasColInstance.findOne({ _model: 'workflowRun' });
+
+        expect(workflowRun).not.toBeNull();
+        expect(workflowRun.status).toBe('completed');
+        expect(workflowRun.workflow.toString()).toBe(testWorkflow._id.toString());
+        expect(workflowRun.contextData.triggerData._id.toString()).toBe(insertResult.insertedIds[0].toString());
+        expect(workflowRun.contextData.triggerData.projectName).toBe('New Corp Website');
+
+    });
+
+    it('ne devrait PAS créer de workflowRun si le trigger est inactif', async () => {
+        await initTest();
+        // 1. Arrange: Créer un déclencheur INACTIF
+        await insertData('workflowTrigger', {
+            name: 'Inactive Trigger',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataAdded',
+            isActive: false, // Inactif
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Insérer des données
+        await insertData(targetDataModel.name, { projectName: 'Secret Project', status: 'new' }, {}, mockUser, true);
+
+        // 3. Assert: Aucun `workflowRun` ne doit être créé
+        const workflowRunCount = await testDatasColInstance.countDocuments({ _model: 'workflowRun' });
+        expect(workflowRunCount).toBe(0);
+    });
+
+    it('devrait créer un workflowRun si le dataFilter est satisfait', async () => {
+        await initTest();
+        // 1. Arrange: Créer un déclencheur avec un `dataFilter`
+        await insertData('workflowTrigger', {
+            name: 'Trigger for Active Projects',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataAdded',
+            isActive: true,
+            dataFilter: { $eq: ['$status', 'active'] }, // Filtre pour status = 'active'
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Insérer des données qui correspondent au filtre
+        await insertData(targetDataModel.name, { projectName: 'Go-Live Project', status: 'active' }, {}, mockUser, true, true);
+
+        // 3. Assert: Un `workflowRun` doit être créé
+        const workflowRunCount = await testDatasColInstance.countDocuments({ _model: 'workflowRun' });
+        expect(workflowRunCount).toBe(1);
+    });
+
+    it('ne devrait PAS créer de workflowRun si le dataFilter n\'est PAS satisfait', async () => {
+        await initTest();
+        // 1. Arrange: Créer un déclencheur avec un `dataFilter`
+        await insertData('workflowTrigger', {
+            name: 'Trigger for Archived Projects',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataAdded',
+            isActive: true,
+            dataFilter: { $eq: ['$status', 'archived'] }, // Filtre pour status = 'archived'
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Insérer des données qui NE correspondent PAS au filtre
+        await insertData(targetDataModel.name, { projectName: 'Ongoing Project', status: 'active' }, {}, mockUser, true, true);
+
+        // 3. Assert: Aucun `workflowRun` ne doit être créé
+        const workflowRunCount = await testDatasColInstance.countDocuments({ _model: 'workflowRun' });
+        expect(workflowRunCount).toBe(0);
+    });
+
+    it('devrait déclencher un workflow "DataEdited" lors de la modification de données', async () => {
+        await initTest();
+        // 1. Arrange: Insérer une donnée initiale et un déclencheur pour 'DataEdited'
+        const insertResult = await insertData(targetDataModel.name, { projectName: 'To Edit', status: 'initial' }, {}, mockUser, false);
+        const projectId = insertResult.insertedIds[0];
+
+        await insertData('workflowTrigger', {
+            name: 'Trigger on Project Edit',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataEdited',
+            isActive: true,
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Modifier la donnée
+        const editResult = await patchData(targetDataModel.name, projectId, { status: 'edited' }, {}, mockUser, true, true);
+        expect(editResult.success).toBe(true);
+
+        // 2. Act: Modifier la donnée
+        const editResult2 = await editData(targetDataModel.name, projectId, { projectName: 'test', status: 'edited' }, {}, mockUser, true, true);
+        expect(editResult2.success).toBe(true);
+
+        const workflows = await testDatasColInstance.countDocuments({ _model: 'workflowRun' });
+        expect(workflows).toBe(2);
+    });
+
+    it('devrait déclencher un workflow "DataDeleted" lors de la suppression de données', async () => {
+        await initTest();
+        // 1. Arrange: Insérer une donnée et un déclencheur pour 'DataDeleted'
+        const insertResult = await insertData(targetDataModel.name, { projectName: 'To Delete', status: 'temp' }, {}, mockUser, false);
+        const projectId = insertResult.insertedIds[0];
+
+        await insertData('workflowTrigger', {
+            name: 'Trigger on Project Delete',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataDeleted',
+            isActive: true,
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Supprimer la donnée
+        const deleteResult = await deleteData(targetDataModel.name, [projectId], {}, mockUser, true, true);
+        expect(deleteResult.success).toBe(true);
+
+        // 3. Assert: Un `workflowRun` doit être créé
+        const workflowRun = await testDatasColInstance.findOne({ _model: 'workflowRun' });
+        expect(workflowRun).not.toBeNull();
+        // Le `triggerData` est le document *avant* sa suppression
+        expect(workflowRun.contextData.triggerData.projectName).toBe('To Delete');
+    });
+});

package/test/workflow.robustness.test.js

@@ -0,0 +1,195 @@
+import { ObjectId } from 'mongodb';
+import { expect, describe, it, beforeEach, afterAll, beforeAll, vi } from 'vitest';
+import { Config } from "data-primals-engine/config";
+
+// --- Configuration initiale (similaire à workflow.integration.test.js) ---
+let mongod;
+let testDbUri;
+const testDbName = 'testRobustnessDbHO_Workflow';
+
+// --- Importations des modules de l'application ---
+import { Engine } from "data-primals-engine/engine";
+import { insertData, editData } from 'data-primals-engine/modules/data';
+import { modelsCollection as getAppModelsCollection, getCollectionForUser, getCollection } from 'data-primals-engine/modules/mongodb';
+import * as workflowModule from 'data-primals-engine/modules/workflow';
+import {getUniquePort, initEngine} from "../src/setenv.js";
+import {maxExecutionsByStep} from "data-primals-engine/constants";
+
+vi.mock('data-primals-engine/modules/workflow', { spy: true })
+
+const mockUser = {
+    username: 'robustnessUser',
+    _user: 'robustnessUser',
+    email: 'robustness@example.com'
+};
+
+// Recopie des méta-modèles pour la lisibilité
+const workflowMetaModels = [
+    { name: 'workflow', 'description': '', _user: mockUser.username, fields: [{ name: 'name', type: 'string' }, { name: 'startStep', type: 'relation', relation: 'workflowStep' }] },
+    { name: 'workflowStep', 'description': '', _user: mockUser.username, fields: [{ name: 'name', type: 'string' }, { name: 'onSuccessStep', type: 'relation', relation: 'workflowStep' }, { name: 'onFailureStep', type: 'relation', relation: 'workflowStep' }, { name: 'isTerminal', type: 'boolean' }, { name: 'actions', type: 'array', itemsType: 'relation', relation: 'workflowAction' }, { name: 'conditions', type: 'object' }] },
+    { name: 'workflowTrigger', 'description': '', _user: mockUser.username, fields: [{ name: 'name', type: 'string' }, { name: 'targetModel', type: 'model' }, { name: 'onEvent', type: 'enum', items: ['DataAdded'] }, { name: 'isActive', type: 'boolean' }, { name: 'dataFilter', type: 'object' }, { name: 'workflow', type: 'relation', relation: 'workflow' }] },
+    { name: 'workflowRun',  'description': '',_user: mockUser.username, fields: [{ name: 'status', type: 'enum', items: ['pending', 'running', 'completed', 'failed', 'cancelled'] }, { name: 'workflow', type: 'relation', relation: 'workflow' }, { name: 'contextData', type: 'object' }, { name: 'currentStep', type: 'relation', relation: 'workflowStep' }, { name: 'error', type: 'string' }, { name: 'completedAt', type: 'datetime' }, { name: 'stepExecutionsCount', type: 'object' }] },
+    { name: 'workflowAction', 'description': '', _user: mockUser.username, fields: [{ name: 'name', type: 'string' }, { name: 'type', type: 'enum', items: ['Log'] }] }
+];
+const targetDataModel = { name: 'project',  'description': '',_user: mockUser.username, fields: [{ name: 'projectName', type: 'string' }, { name: 'status', type: 'string' }] };
+
+
+let testModelsColInstance;
+let testDatasColInstance;
+
+beforeAll(async () =>{
+    Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
+    await initEngine();
+})
+
+beforeEach(async () => {
+    testModelsColInstance = getAppModelsCollection;
+    testDatasColInstance = getCollectionForUser(mockUser);
+    await testDatasColInstance.deleteMany({ _user: mockUser.username });
+    await getCollection('job_locks').deleteMany({}); // Nettoyer les verrous
+    const mods = await testModelsColInstance.find({ $and: [{_user: mockUser.username}, {$or: [{name: targetDataModel.name}, ...workflowMetaModels.map(m =>({name: m.name}))] }]}).toArray();
+    console.log({mods})
+    if( mods.length === 0){
+        await testModelsColInstance.insertMany([targetDataModel, ...workflowMetaModels]);
+    }
+});
+
+// ====================================================================================
+// =================== DÉBUT DES TESTS DE ROBUSTESSE ==================================
+// ====================================================================================
+
+describe('Tests de robustesse et des cas limites du module Workflow', () => {
+
+    describe('Verrouillage distribué (runScheduledJobWithDbLock)', () => {
+
+        it('ne devrait pas exécuter la fonction si un verrou est déjà actif', async () => {
+            const jobsCollection = getCollection('job_locks');
+            const jobId = 'concurrent-job-1';
+            const jobFunctionSpy = vi.fn();
+
+            // 1. Arrange: Insérer manuellement un verrou actif dans la DB
+            const now = new Date();
+            await jobsCollection.insertOne({
+                jobId: jobId,
+                lockedUntil: new Date(now.getTime() + 10 * 60 * 1000), // Verrouillé pour 10 min
+            });
+
+            // 2. Act: Tenter de lancer le job
+            await workflowModule.runScheduledJobWithDbLock(jobId, jobFunctionSpy);
+
+            // 3. Assert: La fonction ne doit JAMAIS avoir été appelée
+            expect(jobFunctionSpy).not.toHaveBeenCalled();
+        });
+
+        it('devrait acquérir un verrou expiré et exécuter la fonction', async () => {
+            const jobsCollection = getCollection('job_locks');
+            const jobId = 'expired-lock-job-1';
+            const jobFunctionSpy = vi.fn();
+
+            // 1. Arrange: Insérer un verrou qui a déjà expiré (simule un crash)
+            await jobsCollection.insertOne({
+                jobId: jobId,
+                lockedUntil: new Date(Date.now() - 1000), // Expiré depuis 1 seconde
+            });
+
+            // 2. Act: Lancer le job
+            await workflowModule.runScheduledJobWithDbLock(jobId, jobFunctionSpy);
+
+            // 3. Assert: La fonction a bien été exécutée car le verrou a été repris
+            expect(jobFunctionSpy).toHaveBeenCalledTimes(1);
+        });
+
+        it('devrait libérer le verrou même si la jobFunction lve une exception', async () => {
+            const jobsCollection = getCollection('job_locks');
+            const jobId = 'job-with-exception';
+            // 1. Arrange: Créer une fonction qui échoue systématiquement
+            const failingJobFunction = vi.fn().mockRejectedValue(new Error('Erreur de traitement interne'));
+
+            // 2. Act: Exécuter la fonction. On s'attend à ce qu'elle gère l'erreur en interne.
+            await expect(workflowModule.runScheduledJobWithDbLock(jobId, failingJobFunction)).resolves.not.toThrow();
+
+            // 3. Assert:
+            // - La fonction a bien été tentée
+            expect(failingJobFunction).toHaveBeenCalledTimes(1);
+            // - Le verrou a quand même été libéré (c'est le test le plus important ici)
+            const lockInDb = await jobsCollection.findOne({ jobId: jobId });
+            expect(lockInDb).not.toBeNull();
+            // La date d'expiration est mise à une date passée (ici, l'époque UNIX 0)
+            expect(lockInDb.lockedUntil.getTime()).toBe(new Date(0).getTime());
+        });
+    });
+
+    describe('Moteur de Workflow (processWorkflowRun)', () => {
+
+        it('devrait arrêter un workflow en boucle et le marquer comme "failed"', async () => {
+            // 1. Arrange: Créer un workflow qui boucle sur lui-même
+            const action = (await insertData('workflowAction', { name: 'Log Action', type: 'Log' }, {}, mockUser)).insertedIds[0];
+            const step1 = (await insertData('workflowStep', { name: 'Step 1', actions: [action] }, {}, mockUser)).insertedIds[0];
+            const step2 = (await insertData('workflowStep', { name: 'Step 2', onSuccessStep: step1.toString() }, {}, mockUser)).insertedIds[0];
+            await editData('workflowStep', step1, { onSuccessStep: step2.toString() }, {}, mockUser);
+
+            const workflow = (await insertData('workflow', { name: 'Looping Workflow', startStep: step1.toString() }, {}, mockUser)).insertedIds[0];
+            const run = (await insertData('workflowRun', { workflow: workflow, status: 'pending', contextData: {} }, {}, mockUser)).insertedIds[0];
+
+            // 2. Act: Lancer le traitement du workflow
+            await workflowModule.processWorkflowRun(run, mockUser);
+
+            // 3. Assert: Le workflow a été arrêté et marqué comme échoué
+            const finalRun = await testDatasColInstance.findOne({ _id: new ObjectId(run) });
+            expect(finalRun.status).toBe('failed');
+            expect(finalRun.error).toContain("Maximum executions ("+maxExecutionsByStep+") exceed");
+            // Vérifier que le compteur de steps a bien augmenté
+            expect(Object.keys(finalRun.stepExecutionsCount).length).toBeGreaterThan(1);
+        }, 10000); // Timeout un peu plus long pour ce test
+
+        it('devrait suivre le chemin "onFailureStep" si les conditions ne sont pas remplies', async () => {
+            // 1. Arrange:
+            const successAction = (await insertData('workflowAction', { name: 'Success Action', type: 'Log' }, {}, mockUser)).insertedIds[0];
+            const failureAction = (await insertData('workflowAction', { name: 'Failure Action', type: 'Log' }, {}, mockUser)).insertedIds[0];
+
+            const successStep = (await insertData('workflowStep', { name: 'Success Step', actions: [successAction], isTerminal: true }, {}, mockUser)).insertedIds[0];
+            const failureStep = (await insertData('workflowStep', { name: 'Failure Step', actions: [failureAction], isTerminal: true }, {}, mockUser)).insertedIds[0];
+
+            const startStepDef = {
+                name: 'Conditional Step',
+                // Cette condition est conçue pour échouer car la donnée n'existera pas
+                conditions: { status: 'must-be-this-to-succeed' },
+                onSuccessStep: successStep.toString(),
+                onFailureStep: failureStep.toString(),
+            };
+            const startStep = (await insertData('workflowStep', startStepDef, {}, mockUser)).insertedIds[0];
+            const workflow = (await insertData('workflow', { name: 'Failure Path Workflow', startStep: startStep.toString() }, {}, mockUser)).insertedIds[0];
+            const run = (await insertData('workflowRun', { workflow: workflow, status: 'pending', contextData: { triggerDataModel: 'project' } }, {}, mockUser)).insertedIds[0];
+
+            // 2. Act
+            await workflowModule.processWorkflowRun(run, mockUser);
+
+            // 3. Assert
+            const finalRun = await testDatasColInstance.findOne({ _id: new ObjectId(run) });
+
+            // Le workflow doit se terminer avec le statut 'completed', car une condition
+            // non remplie est une branche valide, pas une erreur système.
+            expect(finalRun.status).toBe('completed');
+            expect(finalRun.error).toBeNull(); // Aucune erreur ne doit être enregistrée
+            expect(finalRun.stepExecutionsCount[startStep]).toBe(1); // Aucune erreur ne doit être enregistrée
+            expect(finalRun.stepExecutionsCount[failureStep]).toBe(1); // Aucune erreur ne doit être enregistrée
+
+        }, 10000);
+
+        it('devrait échouer proprement si une définition d\'étape est introuvable', async () => {
+            // 1. Arrange: Créer un workflow qui pointe vers un step ID invalide
+            const nonExistentStepId = new ObjectId().toString();
+            const workflow = (await insertData('workflow', { name: 'Broken Workflow', startStep: nonExistentStepId }, {}, mockUser)).insertedIds[0];
+            const run = (await insertData('workflowRun', { workflow: workflow, status: 'pending' }, {}, mockUser)).insertedIds[0];
+
+            // 2. Act
+            await workflowModule.processWorkflowRun(run, mockUser);
+
+            // 3. Assert
+            const finalRun = await testDatasColInstance.findOne({ _id: new ObjectId(run) });
+            expect(finalRun.status).toBe('failed');
+            expect(finalRun.error).toContain(`Step definition ID: ${nonExistentStepId} not found`);
+        });
+    });
+
+});

package/vitest.config.js

@@ -0,0 +1,16 @@
+// vitest.config.js
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        // Set a generous timeout for the global setup/teardown hooks themselves.
+        // This is important because starting a server can be slow.
+        hookTimeout: 60000, // 60 seconds
+
+        // A default timeout for individual tests
+        testTimeout: 25000, // 20 seconds
+
+        // Tell Vitest where to find your global setup and teardown files
+        globalTeardown: './test/globalTeardown.js',
+    },
+});