data-primals-engine 1.7.1 → 1.7.3

package/test/import_export.integration.test.js

@@ -1,211 +1,211 @@
-import {expect, describe, it, beforeEach, beforeAll, afterAll, vi, afterEach} from 'vitest';
-
-// --- Importations des modules de votre application ---
-import {
-    insertData,
-    exportData,
-    importData
-} from '../src/index.js';
-
-import {
-    modelsCollection as getAppModelsCollection,
-    getCollectionForUser as getAppUserCollection, getCollectionForUser
-} from '../src/modules/mongodb.js';
-import {sleep} from "../src/core.js";
-import fs from "node:fs";
-import {initEngine} from "../src/setenv.js";
-import {Config} from "../src/index.js";
-
-// --- Données Mock ---
-const mockUser = {
-    username: 'testuserImpex',
-    _user: 'testuserImpex',
-    userPlan: 'premium',
-    email: 'testImpex@example.com'
-};
-
-const impexTestModel = {
-    name: 'impex_products',
-    description: 'test',
-    _user: mockUser.username,
-    fields: [
-        { name: 'name', type: 'string', required: true },
-        { name: 'sku', type: 'string', unique: true },
-        { name: 'price', type: 'number', required: true },
-        { name: 'inStock', type: 'boolean', default: true }
-    ]
-};
-
-// --- Setup de l'environnement de test ---
-let testModelsColInstance;
-let testDatasColInstance;
-
-function blobToFile(theBlob, fileName){
-    //A Blob() is almost a File() - it's just missing the two properties below which we will add
-    theBlob.lastModifiedDate = new Date();
-    theBlob.name = fileName;
-    return theBlob;
-}
-
-beforeAll(async () =>{
-    Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
-    await initEngine();
-})
-
-beforeEach(async() =>{
-// tell vitest we use mocked time
-    vi.useFakeTimers({ shouldAdvanceTime: true })
-})
-
-afterEach(() => {
-    vi.runOnlyPendingTimers();
-    // restoring date after each test run
-    vi.useRealTimers()
-})
-afterAll(async () => {
-    const coll = await getCollectionForUser(mockUser);
-    await coll.drop();
-})
-// --- Début des tests ---
-describe('Intégration des fonctions d\'Import/Export', () => {
-
-    // Préparation avant chaque test du bloc
-    beforeEach(async () => {
-        testModelsColInstance = getAppModelsCollection;
-        testDatasColInstance = await getAppUserCollection(mockUser);
-
-        // Nettoyage complet pour un état propre
-        await testDatasColInstance.deleteMany({ _user: "testuserImpex"});
-
-        if( await testModelsColInstance.find({ name: impexTestModel.name, _user: mockUser.username }).count() === 0) {
-            await testModelsColInstance.insertOne(impexTestModel);
-        }
-        // Insérer des données de base pour les tests d'exportation
-        await insertData(impexTestModel.name, [
-            { name: 'Produit A', sku: 'SKU-A', price: 10.50, inStock: true },
-            { name: 'Produit B', sku: 'SKU-B', price: 25.00, inStock: false },
-            { name: 'Produit C', sku: 'SKU-C', price: 99.99, inStock: true }
-        ], {}, mockUser, false);
-    });
-
-    describe('Export de données', () => {
-        it('devrait exporter les données en format JSON', async () => {
-
-            const res= await exportData({
-                models: [impexTestModel.name],
-                depth: 1
-            }, mockUser);
-
-            expect(res.success).toBeTruthy();
-
-            const data = res.data[impexTestModel.name];
-            expect(data).toBeInstanceOf(Array);
-            expect(data).toHaveLength(3);
-            expect(data[0]).toMatchObject({ name: 'Produit A', sku: 'SKU-A', price: 10.50 });
-            // Les champs système (_id, _model, _user, _hash) ne devraient pas être exportés par défaut
-            expect(data[0]).not.toHaveProperty('_model');
-        });
-
-        it('devrait lever une exception si le modèle n\'existe pas', async () => {
-            // La fonction devrait rejeter la promesse ou lancer une erreur
-            await expect((await exportData('model_inexistant', 'json', mockUser)).success).toBeFalsy();
-        });
-    });
-
-    describe('Import de données', () => {
-        it('devrait importer des données depuis une chaîne JSON', async () => {
-
-            const jsonDataToImport = [
-                { name: 'Produit D', sku: 'SKU-D', price: 1.00, inStock: true },
-                { name: 'Produit E', sku: 'SKU-E', price: 2.00 } // inStock utilisera la valeur par défaut
-            ];
-            const jsonString = JSON.stringify(jsonDataToImport);
-
-            // Exécution de la fonction d'import (hypothétique)x
-            var blob = new Blob([jsonString], {type: "application/json"});
-            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);
-
-            // Vérifications du résultat de l'opération
-            expect(result.success).toBe(true);
-            expect(result.job.jobId).not.toBeNull();
-
-            await sleep(5000);
-
-            // Vérification directe en base de données
-            const importedDocs = await testDatasColInstance.find({
-                _model: impexTestModel.name,
-                sku: { $in: ['SKU-D', 'SKU-E'] }
-            }).toArray();
-
-            expect(importedDocs).toHaveLength(2);
-            const docD = importedDocs.find(d => d.sku === 'SKU-D');
-            const docE = importedDocs.find(d => d.sku === 'SKU-E');
-
-            expect(docD.name).toBe('Produit D');
-            expect(docD.inStock).toBe(true); // Vérification de la valeur par défaut
-            expect(docE.price).toBe(2.00);
-
-        }, 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`;
-
-            // Exécution de la fonction d'import (hypothétique)x
-            var blob = new Blob([csvStringToImport], {type: "text/csv"});
-            fs.writeFileSync('test.csv', csvStringToImport);
-            blob.path = 'test.csv';
-            blob.originalFilename = 'test.csv';
-
-            // Exécution de la fonction d'import
-            const result = await importData({model:impexTestModel.name}, {file: blobToFile(blob, "test.csv")}, mockUser);
-
-            // Vérifications du résultat
-            expect(result.success).toBe(true);
-            expect(result.job.jobId).not.toBeNull();
-
-            await sleep(5000);
-            // Vérification en base de données
-            const importedDocs = await testDatasColInstance.find({
-                _model: impexTestModel.name,
-                sku: { $in: ['SKU-F', 'SKU-G'] }
-            }).toArray();
-
-            expect(importedDocs).toHaveLength(2);
-            const docF = importedDocs.find(d => d.sku === 'SKU-F');
-            const docG = importedDocs.find(d => d.sku === 'SKU-G');
-
-            // Vérification de la conversion des types
-            expect(docF.price).toBe(3.55);
-            expect(docF.inStock).toBe(true);
-            expect(docG.inStock).toBe(false);
-        }, 20000);
-
-        it('devrait rejeter les lignes invalides et rapporter les erreurs', async () => {
-            const csvStringToImport = `name,sku,price,inStock
-Valide H,SKU-H,10,true
-,SKU-I,20,true
-Valide J,SKU-J,,false
-Valide K,SKU-A,40,true`;
-
-            // Exécution de la fonction d'import (hypothétique)x
-            const blob = new Blob([csvStringToImport], {type: "text/csv"});
-            fs.writeFileSync('test.csv', csvStringToImport);
-            blob.path = 'test.csv';
-            blob.originalFilename = 'test.csv';
-
-            const result = await importData({ model: impexTestModel.name }, {file: blobToFile(blob,"test.csv")}, mockUser);
-
-            // L'initiation du job doit réussir
-            expect(result.success).toBe(true);
-            expect(result.job.jobId).not.toBeNull();
-
-            await sleep(5000);
-            // Vérifier que seule les données valides sont en BDD
-            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);
-    });
+import {expect, describe, it, beforeEach, beforeAll, afterAll, vi, afterEach} from 'vitest';
+
+// --- Importations des modules de votre application ---
+import {
+    insertData,
+    exportData,
+    importData
+} from '../src/index.js';
+
+import {
+    modelsCollection as getAppModelsCollection,
+    getCollectionForUser as getAppUserCollection, getCollectionForUser
+} from '../src/modules/mongodb.js';
+import {sleep} from "../src/core.js";
+import fs from "node:fs";
+import {initEngine} from "../src/setenv.js";
+import {Config} from "../src/index.js";
+
+// --- Données Mock ---
+const mockUser = {
+    username: 'testuserImpex',
+    _user: 'testuserImpex',
+    userPlan: 'premium',
+    email: 'testImpex@example.com'
+};
+
+const impexTestModel = {
+    name: 'impex_products',
+    description: 'test',
+    _user: mockUser.username,
+    fields: [
+        { name: 'name', type: 'string', required: true },
+        { name: 'sku', type: 'string', unique: true },
+        { name: 'price', type: 'number', required: true },
+        { name: 'inStock', type: 'boolean', default: true }
+    ]
+};
+
+// --- Setup de l'environnement de test ---
+let testModelsColInstance;
+let testDatasColInstance;
+
+function blobToFile(theBlob, fileName){
+    //A Blob() is almost a File() - it's just missing the two properties below which we will add
+    theBlob.lastModifiedDate = new Date();
+    theBlob.name = fileName;
+    return theBlob;
+}
+
+beforeAll(async () =>{
+    Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
+    await initEngine();
+})
+
+beforeEach(async() =>{
+// tell vitest we use mocked time
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+})
+
+afterEach(() => {
+    vi.runOnlyPendingTimers();
+    // restoring date after each test run
+    vi.useRealTimers()
+})
+afterAll(async () => {
+    const coll = await getCollectionForUser(mockUser);
+    await coll.drop();
+})
+// --- Début des tests ---
+describe('Intégration des fonctions d\'Import/Export', () => {
+
+    // Préparation avant chaque test du bloc
+    beforeEach(async () => {
+        testModelsColInstance = getAppModelsCollection;
+        testDatasColInstance = await getAppUserCollection(mockUser);
+
+        // Nettoyage complet pour un état propre
+        await testDatasColInstance.deleteMany({ _user: "testuserImpex"});
+
+        if( await testModelsColInstance.find({ name: impexTestModel.name, _user: mockUser.username }).count() === 0) {
+            await testModelsColInstance.insertOne(impexTestModel);
+        }
+        // Insérer des données de base pour les tests d'exportation
+        await insertData(impexTestModel.name, [
+            { name: 'Produit A', sku: 'SKU-A', price: 10.50, inStock: true },
+            { name: 'Produit B', sku: 'SKU-B', price: 25.00, inStock: false },
+            { name: 'Produit C', sku: 'SKU-C', price: 99.99, inStock: true }
+        ], {}, mockUser, false);
+    });
+
+    describe('Export de données', () => {
+        it('devrait exporter les données en format JSON', async () => {
+
+            const res= await exportData({
+                models: [impexTestModel.name],
+                depth: 1
+            }, mockUser);
+
+            expect(res.success).toBeTruthy();
+
+            const data = res.data[impexTestModel.name];
+            expect(data).toBeInstanceOf(Array);
+            expect(data).toHaveLength(3);
+            expect(data[0]).toMatchObject({ name: 'Produit A', sku: 'SKU-A', price: 10.50 });
+            // Les champs système (_id, _model, _user, _hash) ne devraient pas être exportés par défaut
+            expect(data[0]).not.toHaveProperty('_model');
+        });
+
+        it('devrait lever une exception si le modèle n\'existe pas', async () => {
+            // La fonction devrait rejeter la promesse ou lancer une erreur
+            await expect((await exportData('model_inexistant', 'json', mockUser)).success).toBeFalsy();
+        });
+    });
+
+    describe('Import de données', () => {
+        it('devrait importer des données depuis une chaîne JSON', async () => {
+
+            const jsonDataToImport = [
+                { name: 'Produit D', sku: 'SKU-D', price: 1.00, inStock: true },
+                { name: 'Produit E', sku: 'SKU-E', price: 2.00 } // inStock utilisera la valeur par défaut
+            ];
+            const jsonString = JSON.stringify(jsonDataToImport);
+
+            // Exécution de la fonction d'import (hypothétique)x
+            var blob = new Blob([jsonString], {type: "application/json"});
+            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);
+
+            // Vérifications du résultat de l'opération
+            expect(result.success).toBe(true);
+            expect(result.jobId).not.toBeNull();
+
+            await sleep(5000);
+
+            // Vérification directe en base de données
+            const importedDocs = await testDatasColInstance.find({
+                _model: impexTestModel.name,
+                sku: { $in: ['SKU-D', 'SKU-E'] }
+            }).toArray();
+
+            expect(importedDocs).toHaveLength(2);
+            const docD = importedDocs.find(d => d.sku === 'SKU-D');
+            const docE = importedDocs.find(d => d.sku === 'SKU-E');
+
+            expect(docD.name).toBe('Produit D');
+            expect(docD.inStock).toBe(true); // Vérification de la valeur par défaut
+            expect(docE.price).toBe(2.00);
+
+        }, 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`;
+
+            // Exécution de la fonction d'import (hypothétique)x
+            var blob = new Blob([csvStringToImport], {type: "text/csv"});
+            fs.writeFileSync('test.csv', csvStringToImport);
+            blob.path = 'test.csv';
+            blob.originalFilename = 'test.csv';
+
+            // Exécution de la fonction d'import
+            const result = await importData({model:impexTestModel.name}, {file: blobToFile(blob, "test.csv")}, mockUser);
+
+            // Vérifications du résultat
+            expect(result.success).toBe(true);
+            expect(result.jobId).not.toBeNull();
+
+            await sleep(5000);
+            // Vérification en base de données
+            const importedDocs = await testDatasColInstance.find({
+                _model: impexTestModel.name,
+                sku: { $in: ['SKU-F', 'SKU-G'] }
+            }).toArray();
+
+            expect(importedDocs).toHaveLength(2);
+            const docF = importedDocs.find(d => d.sku === 'SKU-F');
+            const docG = importedDocs.find(d => d.sku === 'SKU-G');
+
+            // Vérification de la conversion des types
+            expect(docF.price).toBe(3.55);
+            expect(docF.inStock).toBe(true);
+            expect(docG.inStock).toBe(false);
+        }, 20000);
+
+        it('devrait rejeter les lignes invalides et rapporter les erreurs', async () => {
+            const csvStringToImport = `name,sku,price,inStock
+Valide H,SKU-H,10,true
+,SKU-I,20,true
+Valide J,SKU-J,,false
+Valide K,SKU-A,40,true`;
+
+            // Exécution de la fonction d'import (hypothétique)x
+            const blob = new Blob([csvStringToImport], {type: "text/csv"});
+            fs.writeFileSync('test.csv', csvStringToImport);
+            blob.path = 'test.csv';
+            blob.originalFilename = 'test.csv';
+
+            const result = await importData({ model: impexTestModel.name }, {file: blobToFile(blob,"test.csv")}, mockUser);
+
+            // L'initiation du job doit réussir
+            expect(result.success).toBe(true);
+            expect(result.jobId).not.toBeNull();
+
+            await sleep(5000);
+            // Vérifier que seule les données valides sont en BDD
+            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/replication.test.js

@@ -0,0 +1,163 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { queueReplication, onInit, stopReplicationQueue } from '../src/modules/data/data.replication.js';
+import * as clusterModule from '../src/modules/data/data.cluster.js';
+import { Logger } from "../src/index.js"
+
+// Mock Logger to prevent console output
+vi.mock('../src/gameObject.js', () => ({
+    Logger: class {
+        info = vi.fn();
+        warn = vi.fn();
+        error = vi.fn();
+        debug = vi.fn();
+    }
+}));
+
+describe('Data Replication Logic', () => {
+    let mockEngine;
+    let getReplicaNodesForUserSpy;
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+
+        // Mock the engine and its sendToPeer function
+        mockEngine = {
+            peers: [
+                { id: 'self', url: 'http://self:3000' },
+                { id: 'replica-1', url: 'http://replica-1:3000' },
+                { id: 'replica-2', url: 'http://replica-2:3000' }
+            ],
+            getComponent: vi.fn().mockReturnValue(new Logger('mock')),
+            sendToPeer: vi.fn().mockResolvedValue({ ok: true }),
+        };
+
+        // Spy on getReplicaNodesForUser to control its output
+        getReplicaNodesForUserSpy = vi.spyOn(clusterModule, 'getReplicaNodesForUser');
+
+        // Initialize the replication module with the mock engine
+        onInit(mockEngine);
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.restoreAllMocks();
+        stopReplicationQueue();
+        // Clear the queue manually for test isolation
+        const replicationQueue = []; // This is a simplified way to clear it for tests
+        while (replicationQueue.length > 0) {
+            replicationQueue.pop();
+        }
+    });
+
+    it('should queue an operation correctly', async () => {
+        const operation = 'insert';
+        const modelName = 'testModel';
+        const user = { username: 'testuser' };
+        const payload = { data: { name: 'test' } };
+
+        // This test is tricky because replicationQueue is not exported.
+        // We'll test its effect indirectly via processReplicationQueue.
+        queueReplication(operation, modelName, user, payload);
+
+        // We can't directly inspect the queue, so we'll let the processing logic run
+        // and check if the mocks were called.
+        getReplicaNodesForUserSpy.mockReturnValue([{ id: 'replica-1' }]);
+
+        await vi.advanceTimersByTimeAsync(200); // Advance time to trigger processReplicationQueue
+
+        // Check that the processing function tried to get replicas
+        expect(getReplicaNodesForUserSpy).toHaveBeenCalledWith(user.username);
+    });
+
+    it('should process the queue and send operations in batches to correct replicas', async () => {
+        const user1 = { username: 'user1' };
+        const user2 = { username: 'user2' };
+
+        // Mock so user1 replicates to replica-1 and user2 to replica-2
+        getReplicaNodesForUserSpy.mockImplementation((username) => {
+            if (username === 'user1') return [{ id: 'replica-1' }];
+            if (username === 'user2') return [{ id: 'replica-2' }];
+            return [];
+        });
+
+        // Queue operations for different users
+        queueReplication('insert', 'modelA', user1, { data: { a: 1 } });
+        queueReplication('update', 'modelB', user2, { data: { b: 2 } });
+        queueReplication('delete', 'modelC', user1, { ids: ['123'] });
+
+        // Advance timers to trigger the processing
+        await vi.advanceTimersByTimeAsync(200);
+
+        // Assertions
+        expect(mockEngine.sendToPeer).toHaveBeenCalledTimes(2);
+
+        // Check call for replica-1
+        expect(mockEngine.sendToPeer).toHaveBeenCalledWith(
+            'replica-1',
+            '/api/internal/replicate',
+            expect.objectContaining({
+                operations: expect.arrayContaining([
+                    expect.objectContaining({ operation: 'insert', modelName: 'modelA', user: user1 }),
+                    expect.objectContaining({ operation: 'delete', modelName: 'modelC', user: user1 })
+                ])
+            })
+        );
+
+        // Check call for replica-2
+        expect(mockEngine.sendToPeer).toHaveBeenCalledWith(
+            'replica-2',
+            '/api/internal/replicate',
+            expect.objectContaining({
+                operations: expect.arrayContaining([
+                    expect.objectContaining({ operation: 'update', modelName: 'modelB', user: user2 })
+                ])
+            })
+        );
+    });
+
+    it('should not process queue if CLUSTER_SHARED_DATABASE is true', async () => {
+        process.env.CLUSTER_SHARED_DATABASE = 'true';
+
+        queueReplication('insert', 'modelA', { username: 'user1' }, { data: { a: 1 } });
+
+        await vi.advanceTimersByTimeAsync(200);
+
+        expect(mockEngine.sendToPeer).not.toHaveBeenCalled();
+
+        delete process.env.CLUSTER_SHARED_DATABASE; // Cleanup
+    });
+
+    it('should queue a failed batch for retry and re-send it on the next cycle', async () => {
+        const user = { username: 'retry-user' };
+        const payload = { data: { name: 'important-data' } };
+
+        // Configurer le mock pour qu'il échoue la première fois et réussisse la seconde
+        mockEngine.sendToPeer
+            .mockRejectedValueOnce(new Error('Simulated Network Error'))
+            .mockResolvedValue({ ok: true });
+
+        // Toutes les opérations pour cet utilisateur vont vers 'replica-1'
+        getReplicaNodesForUserSpy.mockReturnValue([{ id: 'replica-1' }]);
+
+        // 1. Mettre une opération en file d'attente
+        queueReplication('insert', 'retryModel', user, payload);
+
+        // 2. Premier cycle : processReplicationQueue est appelé, sendToPeer échoue
+        // Advance just enough to trigger one processing cycle (assuming interval is 100ms)
+        await vi.advanceTimersByTimeAsync(100);
+
+        // Vérifier que l'échec a été loggué et que la tentative a eu lieu
+        expect(mockEngine.sendToPeer).toHaveBeenCalledTimes(1);
+
+        // 3. Deuxième cycle : retryFailedBatches est appelé, sendToPeer réussit
+        await vi.advanceTimersByTimeAsync(100);
+
+        // Vérifier que la nouvelle tentative a eu lieu
+        expect(mockEngine.sendToPeer).toHaveBeenCalledTimes(2);
+
+        // Vérifier que les deux appels étaient pour la même réplique avec les mêmes données
+        const firstCallArgs = mockEngine.sendToPeer.mock.calls[0];
+        const secondCallArgs = mockEngine.sendToPeer.mock.calls[1];
+        expect(firstCallArgs).toEqual(secondCallArgs);
+    });
+});