data-primals-engine 1.2.2 → 1.2.3

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 ==================================
 // ====================================================================================