data-primals-engine 1.2.1 → 1.2.3

package/test/file.test.js

@@ -0,0 +1,193 @@
+// __tests__/file.integration.test.js
+import { expect, describe, it, beforeEach, afterEach, beforeAll, afterAll, vi } from 'vitest';
+import { Config } from '../src/config.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ObjectId } from 'mongodb';
+import { initEngine, generateUniqueName } from "../src/setenv.js";
+import { addFile, removeFile, getFile, onInit } from "../src/modules/file.js";
+import {getCollection, getUserCollectionName} from "../src/modules/mongodb.js";
+import { Logger } from "../src/gameObject.js";
+import {maxPrivateFileSize} from "../src/constants.js";
+import {getCollectionForUser} from "data-primals-engine/modules/mongodb";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+vi.stubEnv('ENCRYPTION_KEY', '12345678901234567890123456789012');
+
+// Mock pour les fichiers uploadés
+const createMockFile = (name, size, type = 'text/plain') => {
+    const tempPath = path.join(__dirname, 'temp', name);
+    fs.writeFileSync(tempPath, 'a'.repeat(size));
+    return {
+        name,
+        size,
+        type,
+        path: tempPath
+    };
+};
+let engine;
+const testUploadDir = path.join(process.cwd(), "uploads", "private");
+const testTempDir = path.join(__dirname, 'temp');
+let filesCollection;
+
+beforeAll(async () => {
+    Config.Set("modules", ["mongodb", "data", "file", "bucket", "user","file"]);
+    engine= await initEngine();
+    await onInit(engine);
+
+    // Créer les répertoires nécessaires
+    if (!fs.existsSync(testUploadDir)) {
+        fs.mkdirSync(testUploadDir, { recursive: true });
+    }
+    if (!fs.existsSync(testTempDir)) {
+        fs.mkdirSync(testTempDir, { recursive: true });
+    }
+
+    filesCollection = await getCollection("files");
+});
+let testUser = {
+    username: generateUniqueName('testuser'),
+    _user: generateUniqueName('testuser'),
+    userPlan: 'premium',
+    permissions: ['API_UPLOAD_FILE']
+};
+
+describe('File Module Integration Tests', () => {
+
+    beforeEach(async () => {
+        // Créer un utilisateur de test
+        // Nettoyer les collections avant chaque test
+        await filesCollection.deleteMany({});
+
+        // Nettoyer le répertoire upload
+        const files = fs.readdirSync(testUploadDir);
+        for (const file of files) {
+            fs.unlinkSync(path.join(testUploadDir, file));
+        }
+    });
+
+    afterAll(async () => {
+        // Nettoyer après tous les tests
+        await filesCollection.deleteMany({});
+        if (fs.existsSync(testUploadDir)) {
+            fs.rmSync(testUploadDir, { recursive: true });
+        }
+        if (fs.existsSync(testTempDir)) {
+            fs.rmSync(testTempDir, { recursive: true });
+        }
+    });
+
+    describe('addFile', () => {
+        it('should successfully add a file with local storage', async () => {
+            const mockFile = createMockFile('test.txt', 1024); // 1KB file
+
+            const guid = await addFile(mockFile, testUser);
+
+            // Vérifier le retour
+            expect(guid).toBeDefined();
+            expect(guid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+
+            // Vérifier en base de données
+            const fileRecord = await filesCollection.findOne({ guid });
+            expect(fileRecord).toBeDefined();
+            expect(fileRecord.filename).toBeDefined();
+            expect(fileRecord.size).toBe(1024);
+            expect(fileRecord.user).toBe(testUser.username);
+            expect(fileRecord.storage).toBe('local');
+
+            // Vérifier que le fichier existe physiquement
+            const expectedPath = path.join(testUploadDir, `${guid}.txt`);
+            expect(fs.existsSync(expectedPath)).toBe(true);
+        });
+
+        it('should throw error when file size exceeds limit', async () => {
+            const mockFile = createMockFile('large.txt', maxPrivateFileSize+1); // 11MB (dépasse la limite de 10MB)
+
+            await expect(addFile(mockFile, testUser)).rejects.toThrow(/La taille du fichier dépasse la limite autorisée/);
+        });
+
+        it.skip('should throw error when storage limit exceeded', async ({skip}) => {
+            // Mock la fonction de calcul d'usage pour simuler un dépassement
+            vi.spyOn(engine.userProvider, 'getUserStorageLimit').mockResolvedValue(85 * 1024 * 1024); // 5MB
+
+            const mockFile = createMockFile('test.txt', 1024 * 1024); // 1MB
+
+            await expect(addFile(mockFile, testUser)).rejects.toThrow("api.data.storageLimitExceeded");
+        });
+
+        it.skip('should throw error when server capacity is insufficient', async ({skip}) => {
+            // Mock la vérification de capacité serveur
+            vi.spyOn(engine.userProvider, 'checkServerCapacity').mockResolvedValue({ isSufficient: false });
+
+            const mockFile = createMockFile('test.txt', 1024);
+
+            await expect(addFile(mockFile, testUser)).rejects.toThrow("api.data.serverStorageFull");
+        });
+    });
+
+    describe('removeFile', () => {
+        it('should successfully remove a locally stored file', async () => {
+            // D'abord ajouter un fichier
+            const mockFile = createMockFile('to-delete.txt', 1024);
+            const guid = await addFile(mockFile, testUser);
+
+            // Vérifier qu'il existe avant suppression
+            const beforeDelete = await getFile(guid);
+            expect(beforeDelete).toBeDefined();
+
+            // Supprimer le fichier
+            await removeFile(guid, testUser);
+
+            // Vérifier en base de données
+            const afterDelete = await getFile(guid);
+            expect(afterDelete).toBeNull();
+
+            // Vérifier que le fichier physique a été supprimé
+            const expectedPath = path.join(testUploadDir, `${guid}.txt`);
+            expect(fs.existsSync(expectedPath)).toBe(false);
+        });
+
+        it('should handle trying to remove non-existent file gracefully', async () => {
+            const nonExistentGuid = '123e4567-e89b-12d3-a456-426614174000';
+
+            vi.spyOn(engine.getComponent(Logger), "info");
+
+            // Cela ne devrait pas throw d'erreur
+            await removeFile(nonExistentGuid, testUser);
+
+            // Vérifier que le logger a bien enregistré l'info
+            expect(engine.getComponent(Logger).info).toHaveBeenCalledWith(
+                expect.stringContaining(`Tentative de suppression d'un fichier inexistant`),
+                'warn'
+            );
+        });
+
+        it('should throw error when GUID is invalid', async () => {
+            await expect(removeFile('invalid-guid', testUser)).rejects.toThrow("Le GUID du fichier n'est pas valide.");
+        });
+    });
+
+    describe('getFile', () => {
+        it('should retrieve file metadata', async () => {
+            const mockFile = createMockFile('metadata-test.txt', 2048);
+            const guid = await addFile(mockFile, testUser);
+
+            const fileData = await getFile(guid);
+
+            expect(fileData).toBeDefined();
+            expect(fileData.guid).toBe(guid);
+            expect(fileData.filename).toContain('.txt');
+            expect(fileData.size).toBe(2048);
+            expect(fileData.user).toBe(testUser.username);
+        });
+
+        it('should return null for non-existent file', async () => {
+            const nonExistentGuid = '123e4567-e89b-12d3-a456-426614174000';
+            const fileData = await getFile(nonExistentGuid);
+
+            expect(fileData).toBeNull();
+        });
+    });
+});

package/test/import_export.integration.test.js

@@ -2,20 +2,20 @@ import {expect, describe, it, beforeEach, beforeAll, afterAll, vi} from 'vitest'
 
 // --- Importations des modules de votre application ---
 import {
-    createModel,
     insertData,
     exportData,
     importData
-} from 'data-primals-engine/modules/data';
+} from '../src/index.js';
 
 import {
     modelsCollection as getAppModelsCollection,
-    getCollectionForUser as getAppUserCollection
+    getCollectionForUser as getAppUserCollection, getCollectionForUser
 } from 'data-primals-engine/modules/mongodb';
 import {sleep} from "data-primals-engine/core";
 import fs from "node:fs";
 import {getUniquePort, initEngine} from "../src/setenv.js";
 import {Config} from "../src/index.js";
+import {ObjectId} from "mongodb";
 
 // --- Données Mock ---
 const mockUser = {
@@ -56,6 +56,10 @@ beforeAll(async () =>{
     Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
     await initEngine();
 })
+afterAll(async () => {
+    const coll = await getCollectionForUser(mockUser);
+    await coll.drop();
+})
 // --- Début des tests ---
 describe('Intégration des fonctions d\'Import/Export', () => {
 
@@ -114,13 +118,13 @@ describe('Intégration des fonctions d\'Import/Export', () => {
             fs.writeFileSync('test.json', jsonString);
             blob.path = 'test.json';
             blob.originalFilename = 'test.json';
-            const result = await importData({model: impexTestModel.name}, {file: blobToFile(blob,"test.json")}, mockUser);
+            const result = await importData({model: impexTestModel.name}, {file: blobToFile(blob, "test.json")}, mockUser);
 
             // Vérifications du résultat de l'opération
             expect(result.success).toBe(true);
-            expect(result.jobId).not.toBeNull();
+            expect(result.job.jobId).not.toBeNull();
 
-            await sleep(2000);
+            await sleep(8000)
 
             // Vérification directe en base de données
             const importedDocs = await testDatasColInstance.find({
@@ -136,7 +140,7 @@ describe('Intégration des fonctions d\'Import/Export', () => {
             expect(docD.inStock).toBe(true); // Vérification de la valeur par défaut
             expect(docE.price).toBe(2.00);
 
-        }, 5000);
+        }, 20000);
 
         it('devrait importer des données depuis une chaîne CSV et convertir les types', async () => {
             const csvStringToImport = `name,sku,price,inStock\nProduit F,SKU-F,3.55,true\nProduit G,SKU-G,4.99,false`;
@@ -148,14 +152,13 @@ describe('Intégration des fonctions d\'Import/Export', () => {
             blob.originalFilename = 'test.csv';
 
             // Exécution de la fonction d'import
-            const result = await importData({model:impexTestModel.name}, {file: blobToFile(blob,"test.csv")}, mockUser);
+            const result = await importData({model:impexTestModel.name}, {file: blobToFile(blob, "test.csv")}, mockUser);
 
-            console.log(result)
             // Vérifications du résultat
             expect(result.success).toBe(true);
+            expect(result.job.jobId).not.toBeNull();
 
-            await sleep(2000);
-
+            await sleep(8000);
             // Vérification en base de données
             const importedDocs = await testDatasColInstance.find({
                 _model: impexTestModel.name,
@@ -185,16 +188,17 @@ Valide K,SKU-A,40,true`;
             blob.path = 'test.csv';
             blob.originalFilename = 'test.csv';
 
-            const result = await importData(impexTestModel.name, {file: blobToFile(blob,"test.csv")}, 'csv', mockUser);
+            const result = await importData({ model: impexTestModel.name }, {file: blobToFile(blob,"test.csv")}, mockUser);
 
-            console.log(result);
-            // Vérifications du résultat
-            expect(result.success).toBe(true); // L'opération globale a des erreurs
-            expect(result.job.status).toBe('failed'); // L'opération globale a des erreurs
+            // L'initiation du job doit réussir
+            expect(result.success).toBe(true);
+            expect(result.job.jobId).not.toBeNull();
+
+            await sleep(8000);
 
             // Vérifier que seule les données valides sont en BDD
-            const count = await testDatasColInstance.countDocuments({ _model: impexTestModel.name });
-            expect(count).toBe(3);
-        });
+            const count = await testDatasColInstance.countDocuments({ _model: impexTestModel.name, sku: 'SKU-H' });
+            expect(count).toBe(1); // Seule la ligne valide 'SKU-H' doit être insérée.
+        }, 20000);
     });
 });

package/test/model.integration.test.js

@@ -5,30 +5,31 @@ import { Config } from '../src/config.js';
 
 import {
     modelsCollection as getAppModelsCollection,
-    datasCollection // Accès direct pour vérifications
+    datasCollection, getCollection // Accès direct pour vérifications
 } from 'data-primals-engine/modules/mongodb';
 import {generateUniqueName, getUniquePort, initEngine} from "../src/setenv.js";
 import {editModel} from "../src/modules/data.js";
-import {getCollectionForUser} from "../src/modules/mongodb.js";
+import {getCollectionForUser, getUserCollectionName} from "../src/modules/mongodb.js";
 
 let testModelsColInstance;
-let testDatasColInstance;
-
 let testModelId;
-
+let lastUser;
 // Cette fonction va remplacer la logique de votre beforeEach pour la création de contexte
 async function setupTestContext() {
 
     const currentTestModelName = generateUniqueName('relatedModel');
     const currentRelatedModelName = generateUniqueName('comprehensiveModel');
 
+
     // Créer un utilisateur unique pour ce test
     const currentTestUser = {
-        username: generateUniqueName('testuserDataIntegration'),
-        userPlan: 'free',
+        username: generateUniqueName('testuserModelIntegration'),
+        userPlan: 'premium',
         email: generateUniqueName('test') + '@example.com'
     };
 
+    testModelsColInstance = getCollection("models");
+    const testDatasColInstance = await getCollectionForUser(currentTestUser);
 
     const relatedModelDefinition = {
         name: currentRelatedModelName,
@@ -105,43 +106,42 @@ async function setupTestContext() {
     await testDatasColInstance.deleteMany({ _user: currentTestUser.username });
     await testDatasColInstance.deleteMany({ _model: { $in: [comprehensiveTestModelDefinition.name, 'renamedTestModel'] } });
     // Retourner toutes les variables nécessaires pour un test
+
     return {
         currentTestUser,
+        coll:testDatasColInstance,
         comprehensiveTestModelDefinition,
         relatedModelDefinition
     };
 }
 
+
 describe('CRUD on model definitions and integrity tests', () => {
 
     beforeAll(async () =>{
         Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
         await initEngine();
-
-        // Initialize collection instances after the engine is ready
-        testModelsColInstance = getAppModelsCollection;
-        testDatasColInstance = datasCollection;
     })
+
     describe('editModel unit tests', () => {
 
-        it('should create and drop index when field.index is toggled (premium user)', async () => {
+        it.skip('should create and drop index when field.index is toggled (premium user)', async () => {
             // --- SETUP ---
-            const { currentTestUser, comprehensiveTestModelDefinition } = await setupTestContext();
-            const dataCollection = await getCollectionForUser(currentTestUser);
+            const { coll, currentTestUser, comprehensiveTestModelDefinition } = await setupTestContext();
             const fieldToIndex = 'stringUnique'; // Utiliser un champ qui existe vraiment dans le modèle
 
             // --- FIX: Ensure the collection exists before any operation ---
             // By inserting and deleting a dummy document, we force MongoDB to create the
             // collection and its default indexes. This prevents the "ns does not exist"
             // error in asynchronous listeners (like workflow triggers).
-            const dummyDoc = await dataCollection.insertOne({ _model: 'dummy', _user: currentTestUser.username });
-            await dataCollection.deleteOne({ _id: dummyDoc.insertedId });
+            const dummyDoc = await coll.insertOne({ _model: 'dummy', _user: currentTestUser.username });
+            await coll.deleteOne({ _id: dummyDoc.insertedId });
 
 
             // --- VERIFICATION INITIALE ---
             // S'assurer qu'aucun index n'existe au départ.
             // Cet appel ne plantera plus car la collection est maintenant créée.
-            const initialIndexes = await dataCollection.indexes();
+            const initialIndexes = await coll.indexes();
             expect(initialIndexes.some(i => i.key[fieldToIndex] === 1)).toBe(false);
 
             // --- ACTION 1 : AJOUTER UN INDEX ---
@@ -155,7 +155,7 @@ describe('CRUD on model definitions and integrity tests', () => {
 
             // --- VERIFICATION 1 ---
             // Maintenant, la collection et l'index doivent exister.
-            const indexesAfterCreation = await dataCollection.indexes();
+            const indexesAfterCreation = await coll.indexes();
             const newIndex = indexesAfterCreation.find(i => i.key[fieldToIndex] === 1);
 
             expect(newIndex).toBeDefined();
@@ -175,8 +175,9 @@ describe('CRUD on model definitions and integrity tests', () => {
             await editModel(currentTestUser, testModelId, modelWithoutIndex);
 
             // --- VERIFICATION 2 ---
-            const indexesAfterDeletion = await dataCollection.indexes();
+            const indexesAfterDeletion = await coll.indexes();
             expect(indexesAfterDeletion.some(i => i.key[fieldToIndex] === 1)).toBe(false);
+
         }, 20000);
 
         it('should not save extra, non-defined fields in the model definition', async () => {

package/test/user.test.js

@@ -17,7 +17,7 @@ async function setupTestContext() {
 
 
     // Créer un utilisateur unique pour ce test
-    const username = generateUniqueName('testuserDataIntegration');
+    const username = generateUniqueName('testuserUserIntegration');
     currentTestUser = {
         username,
         userPlan: 'free',
@@ -58,6 +58,8 @@ async function setupTestContext() {
     ]);
     testUser = {...currentTestUser, _id: users.insertedIds[0].toString(), roles: [roleEditor.toString()] };
     adminUser = {...currentTestUser,  _id: users.insertedIds[1].toString(), roles: [roleEditor.toString()] };
+
+    return testDatasColInstance;
 };
 let engine;
 describe('User Permission Logic', () => {
@@ -72,26 +74,24 @@ describe('User Permission Logic', () => {
     // --- Tests pour la fonction principale de calcul ---
     describe('getUserActivePermissions()', () => {
 
-
-        beforeEach(async () =>{
-            await setupTestContext();
-        })
         it('should return base permissions from the user\'s role', async () => {
+            const coll = await setupTestContext();
             const permissions = await getUserActivePermissions(testUser);
             expect(permissions).to.be.an.instanceOf(Set);
             expect(permissions.size).to.equal(2);
             expect(permissions.has('post:read')).to.be.true;
             expect(permissions.has('post:write')).to.be.true;
             expect(permissions.has('post:delete')).to.be.false;
+            await coll.drop();
         });
 
         it('should grant a temporary permission via an exception', async () => {
-
+            const coll = await setupTestContext();
             // Ajoute une exception qui donne la permission de supprimer, expirant demain
             const futureDate = new Date();
             futureDate.setDate(futureDate.getDate() + 1);
 
-            await testDatasColInstance.insertOne({
+            await coll.insertOne({
                 _model: 'userPermission',
                 user: testUser._id,
                 permission: permDelete,
@@ -104,15 +104,18 @@ describe('User Permission Logic', () => {
             expect(permissions.has('post:delete')).to.be.true;
 
             // Nettoyage de l'exception pour ne pas affecter les autres tests
-            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.deleteOne({ _model: 'userPermission', user: testUser._id });
+
+            await coll.drop();
         });
 
         it('should NOT grant an expired temporary permission', async () => {
+            const coll = await setupTestContext();
             // Ajoute une exception qui a expiré hier
             const pastDate = new Date();
             pastDate.setDate(pastDate.getDate() - 1);
 
-            await testDatasColInstance.insertOne({
+            await coll.insertOne({
                 _model: 'userPermission',
                 user: testUser._id,
                 permission: permDelete,
@@ -124,15 +127,17 @@ describe('User Permission Logic', () => {
             expect(permissions.size).to.equal(2); // Revient la normale
             expect(permissions.has('post:delete')).to.be.false;
 
-            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.drop();
         });
 
         it('should revoke a base permission via an exception', async () => {
+            const coll = await setupTestContext();
             // L'utilisateur est "Editor", mais on lui retire le droit d'écriture temporairement
             const futureDate = new Date();
             futureDate.setDate(futureDate.getDate() + 1);
 
-            await testDatasColInstance.insertOne({
+            await coll.insertOne({
                 _model: 'userPermission',
                 user: testUser._id,
                 permission: permWrite,
@@ -145,15 +150,17 @@ describe('User Permission Logic', () => {
             expect(permissions.has('post:read')).to.be.true;
             expect(permissions.has('post:write')).to.be.false; // La permission a été retirée
 
-            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.drop();
         });
 
         it('should restore a revoked permission if the revocation has expired', async () => {
+            const coll = await setupTestContext();
             // La révocation a expiré, l'utilisateur devrait retrouver son droit d'écriture
             const pastDate = new Date();
             pastDate.setDate(pastDate.getDate() - 1);
 
-            await testDatasColInstance.insertOne({
+            await coll.insertOne({
                 _model: 'userPermission',
                 user: testUser._id,
                 permission: permWrite,
@@ -165,39 +172,39 @@ describe('User Permission Logic', () => {
             expect(permissions.size).to.equal(2);
             expect(permissions.has('post:write')).to.be.true; // La permission est de retour
 
-            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.drop();
         });
     });
 
     // --- Tests pour la fonction publique `hasPermission` ---
     describe('hasPermission()', () => {
-        beforeEach(async () => {
-            await setupTestContext();
-        });
         it('should return true for a permission the user has', async () => {
-
-
-            console.log(await testDatasColInstance.find({ _model: 'permission' }).toArray());
-            console.log(await testDatasColInstance.find({ _model: 'role' }).toArray());
-            console.log(await testDatasColInstance.find({ _model: 'user' }).toArray());
-            console.log(await testDatasColInstance.find({ _model: 'userPermission' }).toArray());
+            const coll = await setupTestContext();
             const result = await hasPermission('post:read', testUser);
             expect(result).to.be.true;
+            await coll.drop();
         });
 
         it('should return false for a permission the user does not have', async () => {
+            const coll = await setupTestContext();
             const result = await hasPermission('user:manage', testUser);
             expect(result).to.be.false;
+            await coll.drop();
         });
 
         it('should return true if user has at least one of the required permissions', async () => {
+            const coll = await setupTestContext();
             const result = await hasPermission(['user:manage', 'post:write'], testUser);
             expect(result).to.be.true;
+            await coll.drop();
         });
 
         it('should return false if user has none of the required permissions', async () => {
+            const coll = await setupTestContext();
             const result = await hasPermission(['user:manage', 'post:delete'], testUser);
             expect(result).to.be.false;
+            await coll.drop();
         });
     });
 });

package/test/vm.test.js

@@ -0,0 +1,51 @@
+import {expect, describe, it, beforeEach, afterEach, beforeAll, afterAll, vi, vitest} from 'vitest';
+import ivm from "isolated-vm";
+import {sleep} from "data-primals-engine/core";
+
+vi.stubEnv('ENCRYPTION_KEY', '12345678901234567890123456789012');
+
+async function executeSafeJavascript() {
+    const isolate = new ivm.Isolate()
+
+    async function myAsyncFunction(str) {
+        await sleep(1000);
+        console.log("hello"+str)
+    }
+
+    const context = await isolate.createContext();
+    const jail = context.global;
+
+    await jail.set('myAsync', new ivm.Reference(myAsyncFunction));
+
+    const fn = await context.eval(`
+        const normalizeArgs = args => args.map(arg => {
+            if (typeof arg === 'object' && arg !== null) {
+                return JSON.stringify(arg); // Convert objects to strings
+            }
+            return arg;
+        });
+        const t = (...args) => {
+            myAsync.applySyncPromise(null, normalizeArgs(args));
+        }
+        (async function untrusted() { 
+            let str = await t("ok", {"ok":true});
+            return str;
+        })
+    `, { reference: true })
+    const value = await fn.apply(undefined, [], { result: { promise: true } })
+}
+
+
+beforeAll(async () => {
+});
+describe('VM system ingration', () => {
+
+    it('should successfully add a file with local storage', async () => {
+        console.log(await executeSafeJavascript({
+            script: 'const t = await addSync();'
+        }, {}, { username:'test'}));
+
+
+        expect(true).toBe(true);
+    });
+});

package/test/workflow.integration.test.js

@@ -7,6 +7,7 @@ import { modelsCollection as getAppModelsCollection, getCollectionForUser } from
 import * as workflowModule from 'data-primals-engine/modules/workflow';
 import {getUniquePort, initEngine} from "../src/setenv.js";
 import process from "process";
+import {getUserCollectionName} from "../src/modules/mongodb.js";
 
 
 beforeAll(async () =>{
@@ -18,7 +19,7 @@ vi.mock('data-primals-engine/modules/workflow', { spy: true })
 const mockUser = {
     username: 'testuserWorkflow',
     _user: 'testuserWorkflow',
-    userPlan: 'free',
+    userPlan: 'premium',
     email: 'testWorkflow@example.com'
 };
 
@@ -155,6 +156,10 @@ beforeEach(async () => {
     console.log({mods})
 });
 
+afterAll(async () => {
+    const coll = await getCollectionForUser(mockUser);
+    await coll.drop();
+})
 describe('Intégration des Workflows - triggerWorkflows', () => {
 
     let testWorkflow;

package/test/workflow.robustness.test.js

@@ -1,5 +1,5 @@
 import { ObjectId } from 'mongodb';
-import { expect, describe, it, beforeEach, beforeAll, vi } from 'vitest';
+import {expect, describe, it, beforeEach, beforeAll, vi, afterAll} from 'vitest';
 import { Config } from "data-primals-engine/config";
 // --- Importations des modules de l'application ---
 import { insertData, editData } from 'data-primals-engine/modules/data';
@@ -7,6 +7,7 @@ import { modelsCollection as getAppModelsCollection, getCollectionForUser, getCo
 import * as workflowModule from 'data-primals-engine/modules/workflow';
 import {initEngine} from "../src/setenv.js";
 import {maxExecutionsByStep} from "../src/constants.js";
+import {getUserCollectionName} from "../src/modules/mongodb.js";
 
 vi.mock('data-primals-engine/modules/workflow', { spy: true })
 
@@ -47,6 +48,10 @@ beforeEach(async () => {
     }
 });
 
+afterAll(async () => {
+    const coll = await getCollectionForUser(mockUser);
+    await coll.drop();
+})
 // ====================================================================================
 // =================== DÉBUT DES TESTS DE ROBUSTESSE ==================================
 // ====================================================================================