data-primals-engine 1.2.0 → 1.2.2

package/test/events.test.js

@@ -0,0 +1,202 @@
+// events.test.js
+import { Event } from '../src/events.js';
+import {vitest} from "vitest";
+import {expect, describe, it, beforeEach, beforeAll, afterAll} from 'vitest';
+
+describe('Event System', () => {
+    beforeEach(() => {
+        // Clear all events before each test to ensure a clean state
+        for (const system in Event) {
+            if (Event.hasOwnProperty(system) && typeof Event[system] === 'object') {
+                for (const eventName in Event[system]) {
+                    if (Event[system].hasOwnProperty(eventName)) {
+                        delete Event[system][eventName];
+                    }
+                }
+            }
+        }
+    });
+
+    it('should allow listening for and triggering an event', () => {
+        const mockCallback = vitest.fn();
+        const eventName = 'testEvent';
+
+        Event.Listen(eventName, mockCallback);
+        Event.Trigger(eventName);
+
+        expect(mockCallback).toHaveBeenCalledTimes(1);
+    });
+    it('should pass arguments to the event callback', () => {
+        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);
+
+        expect(mockCallback).toHaveBeenCalledTimes(1);
+        expect(mockCallback).toHaveBeenCalledWith(arg1, arg2);
+    });
+
+    it('should allow removing a specific callback', () => {
+        const mockCallback1 = vitest.fn();
+        const mockCallback2 = vitest.fn();
+        const eventName = 'testEventRemoveCallback';
+
+        Event.Listen(eventName, mockCallback1);
+        Event.Listen(eventName, mockCallback2);
+        Event.RemoveCallback(eventName, mockCallback1);
+        Event.Trigger(eventName);
+
+        expect(mockCallback1).not.toHaveBeenCalled();
+        expect(mockCallback2).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not trigger a callback if the event is not listened to', () => {
+        const mockCallback = vitest.fn();
+        const eventName = 'nonExistentEvent';
+
+        Event.Trigger(eventName);
+
+        expect(mockCallback).not.toHaveBeenCalled();
+    });
+
+    it('should handle different systems and layers', () => {
+        const mockCallbackPriority = vitest.fn();
+        const mockCallbackLog = vitest.fn();
+        const eventName = 'testEventMultiSystem';
+
+        Event.Listen(eventName, mockCallbackPriority, 'priority', 'high');
+        Event.Listen(eventName, mockCallbackLog, 'log', 'info');
+
+        Event.Trigger(eventName, 'priority', 'high');
+        expect(mockCallbackPriority).toHaveBeenCalledTimes(1);
+        expect(mockCallbackLog).not.toHaveBeenCalled();
+
+        vitest.clearAllMocks(); // Reset mock counts
+
+        Event.Trigger(eventName, 'log', 'info');
+        expect(mockCallbackPriority).not.toHaveBeenCalled();
+        expect(mockCallbackLog).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw an error if an invalid system or layer is used with Listen', () => {
+        expect(() => {
+            Event.Listen('invalidEvent', () => {}, 'invalidSystem', 'invalidLayer');
+        }).toThrowError(/System 'invalidSystem' does not exist./);
+
+        expect(() => {
+            Event.Listen('invalidEvent', () => {}, 'priority', 'invalidLayer');
+        }).toThrowError(/Layer 'invalidLayer' does not exist/);
+    });
+
+    describe('Event.Trigger result merging', () => {
+        it('should merge objects from multiple callbacks using spread operator', () => {
+            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
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+
+            const result = Event.Trigger(eventName);
+
+            expect(result).toEqual({ a: 1, b: 3, c: 4 });
+        });
+
+        it('should concatenate arrays from multiple callbacks', () => {
+            const eventName = 'mergeArrayEvent';
+            const callback1 = vitest.fn().mockReturnValue([1, 2]);
+            const callback2 = vitest.fn().mockReturnValue([3, 4]);
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+
+            const result = Event.Trigger(eventName);
+
+            expect(result).toEqual([1, 2, 3, 4]);
+        });
+
+        it('should concatenate strings from multiple callbacks', () => {
+            const eventName = 'mergeStringEvent';
+            const callback1 = vitest.fn().mockReturnValue('Hello ');
+            const callback2 = vitest.fn().mockReturnValue('World');
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+
+            const result = Event.Trigger(eventName);
+
+            expect(result).toBe('Hello World');
+        });
+
+        it('should add numbers from multiple callbacks', () => {
+            const eventName = 'mergeNumberEvent';
+            const callback1 = vitest.fn().mockReturnValue(10);
+            const callback2 = vitest.fn().mockReturnValue(20);
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+
+            const result = Event.Trigger(eventName);
+
+            expect(result).toBe(30);
+        });
+
+        it('should perform a logical AND on booleans from multiple callbacks', () => {
+            const eventName = 'mergeBooleanEvent';
+
+            // Case 1: true && true -> true
+            const cb_true1 = vitest.fn().mockReturnValue(true);
+            const cb_true2 = vitest.fn().mockReturnValue(true);
+            Event.Listen(eventName, cb_true1);
+            Event.Listen(eventName, cb_true2);
+            expect(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);
+            Event.RemoveAllCallbacks(eventName);
+
+            // Case 3: false && true -> false
+            Event.Listen(eventName, cb_false1);
+            Event.Listen(eventName, cb_true1);
+            expect(Event.Trigger(eventName)).toBe(false);
+        });
+
+        it('should handle mixed-type return values', () => {
+            const eventName = 'mergeMixedEvent';
+            const callback1 = vitest.fn().mockReturnValue(100); // number
+            const callback2 = vitest.fn().mockReturnValue({ a: 1 }); // object
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+
+            const result = Event.Trigger(eventName);
+
+            // The logic initializes `ret` with the first value (100).
+            // When the second callback returns an object, it re-initializes `ret` to {}
+            // and merges the object. The final result is the object.
+            expect(result).toEqual({ a: 1 });
+        });
+
+        it('should ignore null and undefined return values while merging', () => {
+            const eventName = 'ignoreNullsEvent';
+            const callback1 = vitest.fn().mockReturnValue(null);
+            const callback2 = vitest.fn().mockReturnValue({ data: 'important' });
+            const callback3 = vitest.fn().mockReturnValue(undefined);
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+            Event.Listen(eventName, callback3);
+
+            const result = Event.Trigger(eventName);
+
+            expect(result).toEqual({ data: 'important' });
+        });
+    });
+});

package/test/file.test.js

@@ -0,0 +1,196 @@
+// __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 } from "../src/modules/mongodb.js";
+import { Logger } from "../src/gameObject.js";
+import {maxPrivateFileSize} from "../src/constants.js";
+
+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");
+});
+describe('File Module Integration Tests', () => {
+    let testUser;
+
+
+    beforeEach(async () => {
+        // Créer un utilisateur de test
+        testUser = {
+            username: generateUniqueName('testuser'),
+            _user: generateUniqueName('testuser'),
+            userPlan: 'premium',
+            permissions: ['API_UPLOAD_FILE']
+        };
+
+        // 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('should throw error when storage limit exceeded', async ({skip}) => {
+            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('should throw error when server capacity is insufficient', async ({skip}) => {
+            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/user.test.js

@@ -0,0 +1,203 @@
+import { expect, describe, it, beforeEach, beforeAll, afterAll } from 'vitest';
+import { hasPermission, getUserActivePermissions } from '../src/modules/user.js';
+import {initEngine} from "data-primals-engine/setenv";
+import {generateUniqueName} from "../src/setenv.js";
+import {
+    getCollectionForUser as getAppUserCollection,
+    modelsCollection as getAppModelsCollection
+} from "data-primals-engine/modules/mongodb";
+import {Config} from "../src/index.js";
+let permRead, permWrite, permDelete, permManage;
+let roleEditor;
+let testUser, adminUser, roleViewer;
+let currentTestUser;
+let testModelsColInstance, testDatasColInstance;
+// Cette fonction va remplacer la logique de votre beforeEach pour la création de contexte
+async function setupTestContext() {
+
+
+    // Créer un utilisateur unique pour ce test
+    const username = generateUniqueName('testuserDataIntegration');
+    currentTestUser = {
+        username,
+        userPlan: 'free',
+        _model: 'user',
+        _user: username,
+        email: generateUniqueName('test') + '@example.com'
+    };
+
+    // Initialize collection instances after the engine is ready
+    testModelsColInstance = getAppModelsCollection;
+    testDatasColInstance = await getAppUserCollection(currentTestUser);
+
+    await testDatasColInstance.deleteMany({}); // Nettoyage de la base de test
+    // 1. Créer les permissions
+    const permissions = await testDatasColInstance.insertMany([
+        { _model: 'permission', name: 'post:read', description: 'Lire les articles' },
+        { _model: 'permission', name: 'post:write', description: 'Écrire des articles' },
+        { _model: 'permission', name: 'post:delete', description: 'Supprimer des articles' },
+        { _model: 'permission', name: 'user:manage', description: 'Gérer les utilisateurs' }
+    ]);
+    permRead = permissions.insertedIds[0];
+    permWrite = permissions.insertedIds[1];
+    permDelete = permissions.insertedIds[2];
+    permManage = permissions.insertedIds[3];
+
+    // 2. Créer les rôles
+    const roles = await testDatasColInstance.insertMany([
+        { _user: currentTestUser.username, _model: 'role', name: 'Viewer', permissions: [permRead.toString()] },
+        { _user: currentTestUser.username, _model: 'role', name: 'Editor', permissions: [permRead.toString(), permWrite.toString()] }
+    ]);
+    roleViewer = roles.insertedIds[0];
+    roleEditor = roles.insertedIds[1];
+
+    // 3. Créer les utilisateurs
+    const users = await testDatasColInstance.insertMany([
+        { _user: currentTestUser.username, _model: 'user', roles: [roleEditor.toString()] },
+        { _user: currentTestUser.username, _model: 'user', roles: [roleEditor.toString()] }
+    ]);
+    testUser = {...currentTestUser, _id: users.insertedIds[0].toString(), roles: [roleEditor.toString()] };
+    adminUser = {...currentTestUser,  _id: users.insertedIds[1].toString(), roles: [roleEditor.toString()] };
+};
+let engine;
+describe('User Permission Logic', () => {
+
+    // --- SETUP : Création des données de test avant tous les tests ---
+    beforeAll(async () => {
+        Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
+        engine = await initEngine();
+
+    });
+
+    // --- 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 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;
+        });
+
+        it('should grant a temporary permission via an exception', async () => {
+
+            // Ajoute une exception qui donne la permission de supprimer, expirant demain
+            const futureDate = new Date();
+            futureDate.setDate(futureDate.getDate() + 1);
+
+            await testDatasColInstance.insertOne({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permDelete,
+                isGranted: true,
+                expiresAt: futureDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions.size).to.equal(3);
+            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 });
+        });
+
+        it('should NOT grant an expired temporary permission', async () => {
+            // Ajoute une exception qui a expiré hier
+            const pastDate = new Date();
+            pastDate.setDate(pastDate.getDate() - 1);
+
+            await testDatasColInstance.insertOne({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permDelete,
+                isGranted: true,
+                expiresAt: pastDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            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 });
+        });
+
+        it('should revoke a base permission via an exception', async () => {
+            // 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({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permWrite,
+                isGranted: false, // Révocation
+                expiresAt: futureDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions.size).to.equal(1);
+            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 });
+        });
+
+        it('should restore a revoked permission if the revocation has expired', async () => {
+            // 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({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permWrite,
+                isGranted: false,
+                expiresAt: pastDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            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 });
+        });
+    });
+
+    // --- 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 result = await hasPermission('post:read', testUser);
+            expect(result).to.be.true;
+        });
+
+        it('should return false for a permission the user does not have', async () => {
+            const result = await hasPermission('user:manage', testUser);
+            expect(result).to.be.false;
+        });
+
+        it('should return true if user has at least one of the required permissions', async () => {
+            const result = await hasPermission(['user:manage', 'post:write'], testUser);
+            expect(result).to.be.true;
+        });
+
+        it('should return false if user has none of the required permissions', async () => {
+            const result = await hasPermission(['user:manage', 'post:delete'], testUser);
+            expect(result).to.be.false;
+        });
+    });
+});