data-primals-engine 1.3.0 → 1.3.1

package/test/data.integration.test.js

@@ -1,6 +1,6 @@
 // __tests__/data.integration.test.js
 import { ObjectId } from 'mongodb';
-import {vi, expect, describe, it, beforeEach, beforeAll, afterAll} from 'vitest';
+import {vi, expect, describe, it, afterEach,beforeEach, beforeAll, afterAll} from 'vitest';
 import { Config } from '../src/config.js';
 import {
     insertData,
@@ -16,6 +16,7 @@ import {
 } from '../src/modules/mongodb.js';
 import {getRandom} from "../src/core.js";
 import {generateUniqueName, initEngine} from "../src/setenv.js";
+import {purgeData} from "../src/modules/data/data.history.js";
 
 let testModelsColInstance;
 let testDatasColInstance;
@@ -29,7 +30,7 @@ async function setupTestContext() {
     // Créer un utilisateur unique pour ce test
     const currentTestUser = {
         username: generateUniqueName('testuserDataIntegration'),
-        userPlan: 'free',
+        userPlan: 'premium',
         email: generateUniqueName('test') + '@example.com'
     };
 
@@ -111,11 +112,16 @@ async function setupTestContext() {
     }
     await testDatasColInstance.deleteMany({ _user: currentTestUser.username });
 
+    const purge = async ()=>{
+        await purgeData(currentTestUser);
+    }
+
     // Retourner toutes les variables nécessaires pour un test
     return {
         currentTestUser,
         comprehensiveTestModelDefinition,
-        relatedModelDefinition
+        relatedModelDefinition,
+        purge
     };
 }
 
@@ -127,11 +133,10 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         engine = await initEngine();
 
     })
-
     describe('insertData avec comprehensiveTestModel', () => {
         it('devrait insérer des données valides pour tous les types de champs', async () => {
 
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
             // 1. Créer un suffixe unique pour cette exécution de test
             const testSuffix = getRandom(1000, 9999); // Génère un nombre aléatoire
 
@@ -197,125 +202,143 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             expect(new Date(insertedDoc.datetimeField).getFullYear()).toBe(new Date().getFullYear());
             expect(insertedDoc.booleanDefault).toBe(true);
             expect(insertedDoc.relationSingle.toString()).toBe(relatedDoc1.insertedIds[0].toString());
+
+            await purge();
         }, 10000);
 
         describe('Validations des champs à l\'insertion', () => {
             // --- STRING VALIDATIONS ---
             it('devrait rejeter un string requis non fourni', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringUnique: 'test' /* stringRequired manquant */ }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('stringRequired');
+                await purge();
             });
 
             it('devrait rejeter un string trop long pour maxlength', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', stringMaxLength: '123456' }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('stringMaxLength');
+                await purge();
             });
 
             it('devrait rejeter une valeur dupliquée pour un champ unique (stringUnique)', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req1', stringUnique: 'duplicateMe', 'passwordField': 'pass', number: 1, enumField: 'test' }, {}, currentTestUser, false);
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req2', stringUnique: 'duplicateMe', 'passwordField': 'pass', number: 1, enumField: 'test' }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
+                await purge();
             });
 
             // --- NUMBER VALIDATIONS ---
             it('devrait rejeter un number non numérique', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', number: 'not-a-number' }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('number');
+                await purge();
             });
 
             it('devrait rejeter un number infur à min (numberMinMax)', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', numberMinMax: 5 }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('numberMinMax');
+                await purge();
             });
 
             it('devrait rejeter un number supérieur à max (numberMinMax)', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', numberMinMax: 25 }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('numberMinMax');
+                await purge();
             });
 
             // --- ARRAY VALIDATIONS ---
             it('devrait rejeter un array avec trop d\'items (arrayString maxItems: 2)', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', arrayString: ['a', 'b', 'c'] }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('arrayString');
+                await purge();
             });
 
             it('devrait rejeter un array avec pas assez d\'items (arrayNumber minItems: 1)', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', arrayNumber: [] }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('arrayNumber');
+                await purge();
             });
 
             it('devrait rejeter un array avec un item de type incorrect (arrayNumber)', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', arrayNumber: [1, 'not-a-number', 3] }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('arrayNumber');
+                await purge();
             });
 
             // --- FILE VALIDATIONS (metadata) ---
             it('devrait rejeter un file avec un mimeType non autorisé', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const mockFile = { name: 'test.txt', type: 'text/plain', size: 1024, guid: 'dummy-txt' };
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', fileField: mockFile }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('image/png'); // Ou un message plus spécifique sur mimeTypes
                 expect(result.error).toContain('text/plain'); // Ou un message plus spécifique sur mimeTypes
+                await purge();
             });
 
             it('devrait rejeter un file avec une taille supérieure à maxSize', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const mockFile = { name: 'large.png', type: 'image/png', size: 1024 * 15, guid: 'dummy-large' }; // 15KB > 10KB
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', fileField: mockFile }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('fileField'); // Ou un message plus spécifique sur maxSize
+                await purge();
             });
 
             // --- EMAIL, URL, PHONE, COLOR (basic format) ---
             it('devrait rejeter un email invalide', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', emailField: 'not-an-email' }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('emailField');
+                await purge();
             });
             it('devrait rejeter une URL invalide', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', urlField: 'not a url' }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('urlField');
+                await purge();
             });
             it('devrait rejeter une couleur invalide', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', colorField: '#GGHHII' }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('colorField');
+                await purge();
             });
 
             // --- DATE / DATETIME VALIDATIONS ---
             it('devrait rejeter une date invalide (format)', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', dateField: 'not-a-date' }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('dateField');
+                await purge();
             });
             it('devrait rejeter une date en dehors de min/max (dateMinMax)', async () => {
-                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', dateMinMax: '2024-01-01' }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('dateMinMax');
+                await purge();
             });
 
             // TODO: Ajouter des tests pour les autres types et contraintes (password, richtext, code, object, model, modelField)
@@ -326,7 +349,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         // --- NOUVEAU TEST POUR $find ---
         it('devrait insérer des données avec des relations référencées par $find', async () => {
             // 1. Insérer les documents liés qui seront trouvés par $find
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
             const relatedDocA = await insertData(relatedModelDefinition.name, { relatedName: 'FindMeA', relatedValue: 111 }, {}, currentTestUser, false);
             const relatedDocB = await insertData(relatedModelDefinition.name, { relatedName: 'FindMeB', relatedValue: 222 }, {}, currentTestUser, false);
             const relatedDocC = await insertData(relatedModelDefinition.name, { relatedName: 'FindMeC', relatedValue: 222 }, {}, currentTestUser, false);
@@ -389,6 +412,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             expect(insertedDoc.stringRequired).toBe('DocWithFind');
             expect(insertedDoc.enumField).toBe('beta');
 
+            await purge();
         }, 10000); // Augmenter le timeout si nécessaire
     });
 
@@ -397,7 +421,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         let relatedDocId;
 
         const initTest = async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
             // Insert a base document and a related document to be used in edit tests
             const relatedInsert = await insertData(relatedModelDefinition.name, { relatedName: 'RelForEdit', relatedValue: 50 }, {}, currentTestUser, false);
             relatedDocId = relatedInsert.insertedIds[0];
@@ -412,10 +436,10 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const insertResult = await insertData(comprehensiveTestModelDefinition.name, initialData, {}, currentTestUser, false);
             docToEditId = insertResult.insertedIds[0];
 
-            return { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition };
+            return { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge };
         };
         it('devrait modifier des données valides', async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
             const dataToEdit = { stringRequired: 'Edited String', numberMinMax: 12 };
             const result = await editData(comprehensiveTestModelDefinition.name, docToEditId, dataToEdit, {}, currentTestUser);
 
@@ -425,24 +449,29 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const editedDoc = await testDatasColInstance.findOne({ _id: new ObjectId(docToEditId) });
             expect(editedDoc.stringRequired).toBe('Edited String');
             expect(editedDoc.numberMinMax).toBe(12);
+
+            await purge();
         });
 
         it('devrait rejeter une modification avec un string requis vide', async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
             const result = await editData(comprehensiveTestModelDefinition.name, docToEditId, { stringRequired: '' }, {}, currentTestUser);
             expect(result.success).toBe(false);
             expect(result.error).toContain('stringRequired');
+
+            await purge();
         });
 
         it('devrait rejeter une modification avec un number hors des bornes (numberMinMax)', async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
             const result = await editData(comprehensiveTestModelDefinition.name, docToEditId, { stringRequired: 'test', numberMinMax: 50 }, {}, currentTestUser);
             expect(result.success).toBe(false);
             expect(result.error).toContain('numberMinMax');
+            await purge();
         });
 
         it('devrait rejeter une modification qui viole une contrainte unique (stringUnique)', async ({skip}) => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
             // Insert another doc to create the unique conflict
 
             await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'Other', stringUnique: 'UniqueValue', enumField: 'beta', passwordField: 'pass' }, {}, currentTestUser, false);
@@ -453,6 +482,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             expect(result.success).toBe(false);
             expect(result.error).toContain('UniqueValue');
             expect(result.error).toContain('stringUnique');
+            await purge();
         });
 
         // TODO: Ajouter plus de tests de validation pour editData, similaires à ceux de insertData
@@ -461,7 +491,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
     // --- Tests deleteData (repris de votre exemple, peuvent être gardés tels quels ou adaptés) ---
     describe('deleteData (tests existants)', () => {
         it('supprimer des données par ID (deleteData)', async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
             const dataToDelete = { name: 'Objet à supprimer', value: 300 };
             // Utiliser le modèle simple pour ces tests delete pour ne pas avoir à remplir tous les champs requis de comprehensive
             const simpleModel = { name: 'simpleDeleteModel', _user: currentTestUser.username, description: '', fields: [{ name: 'name', type: 'string' }, { name: 'value', type: 'number' }] };
@@ -477,10 +507,12 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
 
             const deletedDoc = await testDatasColInstance.findOne({ _id: new ObjectId(docId) });
             expect(deletedDoc).toBeNull();
+            await purge();
+            await purge();
         });
 
         it('supprimer des données par filtre (deleteData)', async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
             const simpleModel = { name: 'deleteModelTest', _user: currentTestUser.username, description: '',fields: [{ name: 'name', type: 'string' }, { name: 'value', type: 'number' }] };
             await testModelsColInstance.insertOne(simpleModel);
 
@@ -501,6 +533,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             expect(remainingCount).toBe(0);
             const totalRemaining = await testDatasColInstance.countDocuments({ _user: currentTestUser.username, _model: simpleModel.name });
             expect(totalRemaining).toBe(1);
+            await purge();
         });
     });
 
@@ -509,7 +542,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         let relatedDocId_A1, relatedDocId_A2, relatedDocId_B1;
 
         const initTest =async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
 
             // Insérer des documents liés
             const relA1 = await insertData(relatedModelDefinition.name, { relatedName: 'Rel_Search_A1', relatedValue: 101 }, {}, currentTestUser, false);
@@ -544,11 +577,11 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const insertResult2 = await insertData(comprehensiveTestModelDefinition.name, data2, {}, currentTestUser, false);
             docId2 = insertResult2.insertedIds[0].toString();
 
-            return { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition };
+            return { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge };
         };
 
         it('devrait trouver un document par une condition sur une relation simple ($find)', async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
             const searchParams = {
                 model: comprehensiveTestModelDefinition.name,
                 filter: {
@@ -566,10 +599,11 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             // Vérifier que la relation est bien populée si depth > 0
             expect(data[0].relationSingle).toBeInstanceOf(Object);
             expect(data[0].relationSingle.relatedName).toBe('Rel_Search_A1');
+            await purge();
         });
 
         it('ne devrait pas trouver de document si la condition $find sur relation simple ne correspond pas', async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
             const searchParams = {
                 model: comprehensiveTestModelDefinition.name,
                 filter: {
@@ -582,10 +616,11 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const { data, count } = await searchData(searchParams, currentTestUser);
             expect(count).toBe(0);
             expect(data).toHaveLength(0);
+            await purge();
         });
 
         it('devrait trouver des documents par une condition sur une relation multiple ($find)', async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
             const searchParams = {
                 model: comprehensiveTestModelDefinition.name,
                 filter: {
@@ -604,11 +639,12 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             // Note: searchData with depth > 0 will populate the relationMultiple array
             expect(data[0].relationMultiple).toBeInstanceOf(Array);
             expect(data[0].relationMultiple.some(rel => rel.relatedValue === 102)).toBe(true);
+            await purge();
         });
 
 
         it('devrait trouver des documents en combinant un filtre normal et un filtre $find', async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
             const searchParams = {
                 model: comprehensiveTestModelDefinition.name,
                 filter: {
@@ -623,10 +659,11 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             expect(count).toBe(1);
             expect(data).toHaveLength(1);
             expect(data[0]._id.toString()).toBe(docId1.toString());
+            await purge();
         });
 
         it('devrait retourner un tableau vide si $find ne correspond à aucun document lié', async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
             const searchParams = {
                 model: comprehensiveTestModelDefinition.name,
                 filter: {
@@ -639,6 +676,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const { data, count } = await searchData(searchParams,currentTestUser);
             expect(count).toBe(0);
             expect(data).toHaveLength(0);
+            await purge();
         });
 
     });
@@ -658,7 +696,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         });
 
         it('devrait installer un pack, créer les modèles et insérer les données avec relations via $link', async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
             // 1. Définir le pack de données mock
             const mockPack = {
                 name: 'test-pack-for-install',
@@ -729,10 +767,11 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const playerTwo = insertedUsers.find(u => u.username === 'playerTwo');
             const shield = insertedItems.find(i => i.itemName === 'Shield');
             expect(shield.owner.toString()).toBe(playerTwo._id.toString());
+            await purge();
         }, 10000);
 
         it("ne devrait installer que les modèles valides d'un pack et rapporter les erreurs", async () => {
-            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
             const mockPackWithInvalidModel = {
                 name: 'invalid-model-pack',
                 models: [
@@ -769,6 +808,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             // Vérifier en BDD que le modèle valide a bien été créé
             const validModel = await testModelsColInstance.findOne({ name: 'validPackModel', _user: currentTestUser.username });
             expect(validModel).not.toBeNull();
+            await purge();
         });
 
         it('devrait correctement insérer des données JSON depuis un pack', async () => {

package/test/events.test.js

@@ -17,29 +17,29 @@ describe('Event System', () => {
         }
     });
 
-    it('should allow listening for and triggering an event', () => {
+    it('should allow listening for and triggering an event', async() => {
         const mockCallback = vitest.fn();
         const eventName = 'testEvent';
 
         Event.Listen(eventName, mockCallback);
-        Event.Trigger(eventName);
+        await Event.Trigger(eventName);
 
         expect(mockCallback).toHaveBeenCalledTimes(1);
     });
-    it('should pass arguments to the event callback', () => {
+    it('should pass arguments to the event callback', async() => {
         const mockCallback = vitest.fn();
         const eventName = 'testEventWithArgs';
         const arg1 = 'hello';
         const arg2 = 123;
 
         Event.Listen(eventName, mockCallback, "priority", "medium");
-        Event.Trigger(eventName, "priority", "medium", arg1, arg2);
+        await Event.Trigger(eventName, "priority", "medium", arg1, arg2);
 
         expect(mockCallback).toHaveBeenCalledTimes(1);
         expect(mockCallback).toHaveBeenCalledWith(arg1, arg2);
     });
 
-    it('should allow removing a specific callback', () => {
+    it('should allow removing a specific callback', async() => {
         const mockCallback1 = vitest.fn();
         const mockCallback2 = vitest.fn();
         const eventName = 'testEventRemoveCallback';
@@ -47,22 +47,22 @@ describe('Event System', () => {
         Event.Listen(eventName, mockCallback1);
         Event.Listen(eventName, mockCallback2);
         Event.RemoveCallback(eventName, mockCallback1);
-        Event.Trigger(eventName);
+        await Event.Trigger(eventName);
 
         expect(mockCallback1).not.toHaveBeenCalled();
         expect(mockCallback2).toHaveBeenCalledTimes(1);
     });
 
-    it('should not trigger a callback if the event is not listened to', () => {
+    it('should not trigger a callback if the event is not listened to', async() => {
         const mockCallback = vitest.fn();
         const eventName = 'nonExistentEvent';
 
-        Event.Trigger(eventName);
+        await Event.Trigger(eventName);
 
         expect(mockCallback).not.toHaveBeenCalled();
     });
 
-    it('should handle different systems and layers', () => {
+    it('should handle different systems and layers', async() => {
         const mockCallbackPriority = vitest.fn();
         const mockCallbackLog = vitest.fn();
         const eventName = 'testEventMultiSystem';
@@ -70,13 +70,13 @@ describe('Event System', () => {
         Event.Listen(eventName, mockCallbackPriority, 'priority', 'high');
         Event.Listen(eventName, mockCallbackLog, 'log', 'info');
 
-        Event.Trigger(eventName, 'priority', 'high');
+        await Event.Trigger(eventName, 'priority', 'high');
         expect(mockCallbackPriority).toHaveBeenCalledTimes(1);
         expect(mockCallbackLog).not.toHaveBeenCalled();
 
         vitest.clearAllMocks(); // Reset mock counts
 
-        Event.Trigger(eventName, 'log', 'info');
+        await Event.Trigger(eventName, 'log', 'info');
         expect(mockCallbackPriority).not.toHaveBeenCalled();
         expect(mockCallbackLog).toHaveBeenCalledTimes(1);
     });
@@ -92,7 +92,7 @@ describe('Event System', () => {
     });
 
     describe('Event.Trigger result merging', () => {
-        it('should merge objects from multiple callbacks using spread operator', () => {
+        it('should merge objects from multiple callbacks using spread operator', async() => {
             const eventName = 'mergeObjectEvent';
             const callback1 = vitest.fn().mockReturnValue({ a: 1, b: 2 });
             const callback2 = vitest.fn().mockReturnValue({ b: 3, c: 4 }); // b will be overwritten
@@ -100,12 +100,12 @@ describe('Event System', () => {
             Event.Listen(eventName, callback1);
             Event.Listen(eventName, callback2);
 
-            const result = Event.Trigger(eventName);
+            const result = await Event.Trigger(eventName);
 
             expect(result).toEqual({ a: 1, b: 3, c: 4 });
         });
 
-        it('should concatenate arrays from multiple callbacks', () => {
+        it('should concatenate arrays from multiple callbacks', async() => {
             const eventName = 'mergeArrayEvent';
             const callback1 = vitest.fn().mockReturnValue([1, 2]);
             const callback2 = vitest.fn().mockReturnValue([3, 4]);
@@ -113,12 +113,12 @@ describe('Event System', () => {
             Event.Listen(eventName, callback1);
             Event.Listen(eventName, callback2);
 
-            const result = Event.Trigger(eventName);
+            const result = await Event.Trigger(eventName);
 
             expect(result).toEqual([1, 2, 3, 4]);
         });
 
-        it('should concatenate strings from multiple callbacks', () => {
+        it('should concatenate strings from multiple callbacks', async() => {
             const eventName = 'mergeStringEvent';
             const callback1 = vitest.fn().mockReturnValue('Hello ');
             const callback2 = vitest.fn().mockReturnValue('World');
@@ -126,12 +126,12 @@ describe('Event System', () => {
             Event.Listen(eventName, callback1);
             Event.Listen(eventName, callback2);
 
-            const result = Event.Trigger(eventName);
+            const result = await Event.Trigger(eventName);
 
             expect(result).toBe('Hello World');
         });
 
-        it('should add numbers from multiple callbacks', () => {
+        it('should add numbers from multiple callbacks', async() => {
             const eventName = 'mergeNumberEvent';
             const callback1 = vitest.fn().mockReturnValue(10);
             const callback2 = vitest.fn().mockReturnValue(20);
@@ -139,12 +139,12 @@ describe('Event System', () => {
             Event.Listen(eventName, callback1);
             Event.Listen(eventName, callback2);
 
-            const result = Event.Trigger(eventName);
+            const result = await Event.Trigger(eventName);
 
             expect(result).toBe(30);
         });
 
-        it('should perform a logical AND on booleans from multiple callbacks', () => {
+        it('should perform a logical AND on booleans from multiple callbacks', async() => {
             const eventName = 'mergeBooleanEvent';
 
             // Case 1: true && true -> true
@@ -152,23 +152,23 @@ describe('Event System', () => {
             const cb_true2 = vitest.fn().mockReturnValue(true);
             Event.Listen(eventName, cb_true1);
             Event.Listen(eventName, cb_true2);
-            expect(Event.Trigger(eventName)).toBe(true);
+            expect(await Event.Trigger(eventName)).toBe(true);
             Event.RemoveAllCallbacks(eventName); // Clean up for next case
 
             // Case 2: true && false -> false
             const cb_false1 = vitest.fn().mockReturnValue(false);
             Event.Listen(eventName, cb_true1);
             Event.Listen(eventName, cb_false1);
-            expect(Event.Trigger(eventName)).toBe(false);
+            expect(await Event.Trigger(eventName)).toBe(false);
             Event.RemoveAllCallbacks(eventName);
 
             // Case 3: false && true -> false
             Event.Listen(eventName, cb_false1);
             Event.Listen(eventName, cb_true1);
-            expect(Event.Trigger(eventName)).toBe(false);
+            expect(await Event.Trigger(eventName)).toBe(false);
         });
 
-        it('should handle mixed-type return values', () => {
+        it('should handle mixed-type return values', async() => {
             const eventName = 'mergeMixedEvent';
             const callback1 = vitest.fn().mockReturnValue(100); // number
             const callback2 = vitest.fn().mockReturnValue({ a: 1 }); // object
@@ -176,7 +176,7 @@ describe('Event System', () => {
             Event.Listen(eventName, callback1);
             Event.Listen(eventName, callback2);
 
-            const result = Event.Trigger(eventName);
+            const result = await Event.Trigger(eventName);
 
             // The logic initializes `ret` with the first value (100).
             // When the second callback returns an object, it re-initializes `ret` to {}
@@ -184,7 +184,7 @@ describe('Event System', () => {
             expect(result).toEqual({ a: 1 });
         });
 
-        it('should ignore null and undefined return values while merging', () => {
+        it('should ignore null and undefined return values while merging', async() => {
             const eventName = 'ignoreNullsEvent';
             const callback1 = vitest.fn().mockReturnValue(null);
             const callback2 = vitest.fn().mockReturnValue({ data: 'important' });
@@ -194,7 +194,7 @@ describe('Event System', () => {
             Event.Listen(eventName, callback2);
             Event.Listen(eventName, callback3);
 
-            const result = Event.Trigger(eventName);
+            const result = await Event.Trigger(eventName);
 
             expect(result).toEqual({ data: 'important' });
         });

package/test/globalTeardown.js

@@ -3,6 +3,7 @@ import { stopEngine } from '../src/setenv.js';
 
 export default async function () {
     console.log('\n--- Global Teardown: Stopping engine and database ---');
+
     await stopEngine();
     console.log('--- Global Teardown: Cleanup complete. ---');
 }