data-primals-engine 1.2.2 → 1.2.4

package/src/packs.js

@@ -1,4 +1,4 @@
-import {getModels} from "./modules/data.js";
+import {getModels} from "./modules/data/index.js";
 
 
 /*
@@ -39,6 +39,14 @@ export const getAllPacks = async () => {
         return perms;
     }
 
+    const envSmtp = [
+        { "name": "SMTP_HOST", "value": "smtp.example.com", "description": "SMTP server host for sending emails." },
+        { "name": "SMTP_PORT", "value": "587", "description": "SMTP server port." },
+        { "name": "SMTP_USER", "value": "user@example.com", "description": "Username for SMTP authentication." },
+        { "name": "SMTP_PASS", "value": "your_smtp_password", "description": "Password for SMTP authentication." },
+        { "name": "SMTP_FROM", "value": "\"My Store\" <noreply@example.com>", "description": "The 'From' address for outgoing emails." }
+    ];
+
     const categories = [ 'News', 'Blog', 'Products', 'Services', 'Store', 'Events', 'Forums', 'Contact', 'Support'];
     const tags = [ 'info', 'incident', 'maintenance', 'feature', 'hint', 'bugfix', 'question'];
 
@@ -48,6 +56,242 @@ export const getAllPacks = async () => {
         {name: 'visitor', perms: ['API_SEARCH_DATA_webpage','API_SEARCH_DATA_content', 'API_SEARCH_DATA_lang', 'API_SEARCH_DATA_currency', 'API_SEARCH_DATA_taxonomy']}];
 
     return [
+        {
+            "name": "Marketing & Campaigning",
+            "description": "Launch powerful, personalized, and scalable email campaigns. This pack uses dynamic audiences and a robust workflow to send emails in chunks, ensuring high performance. Depends on the 'Customer Relationship Management (CRM)' pack.",
+            "tags": ["marketing", "email", "campaign", "workflow"],
+            "models": ["env", "contact", "workflow", "workflowStep", "workflowAction", "workflowRun", "workflowTrigger",
+                {
+                    "name": "campaign",
+                    "description": "Defines an email marketing campaign.",
+                    "fields": [
+                        { "name": "name", "type": "string", "required": true, "asMain": true },
+                        { "name": "subject", "type": "string", "required": true },
+                        { "name": "content", "type": "richtext", "required": true },
+                        { "name": "status", "type": "enum", "items": ["draft", "scheduled", "in_progress", "finished", "cancelled"], "default": "draft" },
+                        { "name": "audience", "type": "relation", "relation": "audience" },
+                        { "name": "processedRecipients", "type": "array", "itemsType": "string", "hint": "List of processed contact IDs." }
+                    ]
+                },
+                {
+                    "name": "audience",
+                    "description": "Defines a dynamic segment of contacts based on a filter.",
+                    "fields": [
+                        { "name": "name", "type": "string", "required": true, "asMain": true },
+                        { "name": "description", "type": "string" },
+                        { "name": "filter", "type": "code", "language": "json", "required": true, "conditionBuilder": true, "hint": "A MongoDB filter to select contacts. E.g., { \"tags\": \"newsletter\" }" }
+                    ]
+                }
+            ],
+            "data":{
+                "all": {
+                    "audience": [
+                        {
+                            "name": "Example Audience for Campaigning",
+                            "description": "An example audience targeting specific contacts from the CRM pack.",
+                            "filter": { "$or": [{ "$eq": ["$email", "alice.martin@innovatech.com"] }, { "$eq": ["$email", "bob.durand@globalexports.com"] }] }
+                        }
+                    ],
+                    "campaign": [
+                        {
+                            "name": "Q3 Product Launch",
+                            "subject": "🚀 Discover Our New Products!",
+                            "content": "<h1>Hello {recipient.firstName},</h1><p>We are excited to introduce our latest product line. We think you'll love it!</p><p>Best regards,<br>The Team</p>",
+                            "status": "draft",
+                            "audience": { "$link": { "name": "Example Audience for Campaigning", "_model": "audience" } }
+                        }
+                    ],
+                    "workflow": [{
+                        "name": "Campaign Emailing Workflow",
+                        "description": "A scalable workflow that sends campaign emails in chunks by dynamically querying contacts from an audience.",
+                        "startStep": { "$link": { "name": "Start Campaign Processing", "_model": "workflowStep" } }
+                    }],
+                    "workflowAction": [
+                        {
+                            "name": "Set Campaign to 'in_progress'",
+                            "type": "UpdateData",
+                            "targetModel": "campaign",
+                            "targetSelector": { "_id": "{triggerData._id}" },
+                            "fieldsToUpdate": { "status": "in_progress" }
+                        },
+                        {
+                            "name": "Get Next Recipient Chunk",
+                            "type": "ExecuteScript",
+                            "script": `
+const chunkSize = 10; // Process 10 recipients per run
+const campaign = context.triggerData;
+const audience = await db.findOne("audience",{"_id": campaign.audience});
+
+if (!audience || !audience.filter) {
+logger.error('Campaign audience or audience filter is not defined.');
+return { chunk: [], message: 'Campaign audience or audience filter is not defined.'}; // Returning an empty chunk will stop the workflow.
+}
+
+const processedIds = campaign.processedRecipients || [];
+
+const query = {
+    '$and': [
+        audience.filter,
+        { '$not':{ '$in': ["$_id", processedIds] } }
+    ]
+};
+
+logger.info('Finding next chunk with filter:', JSON.stringify(query));
+
+const searchResult = await db.find('contact', query, { limit: chunkSize });
+const chunk = searchResult.data || [];
+
+logger.info(\`Found \${chunk.length} recipients for the next chunk.\`);
+
+return { chunk }; // This chunk is passed to the next action via context.result
+`
+                        },
+                        {
+                            "name": "Send Email to Chunk",
+                            "type": "SendEmail",
+                            "emailRecipients": ["{context.result.chunk}"],
+                            "emailSubject": "{triggerData.subject}",
+                            "emailContent": "{triggerData.content}"
+                        },
+                        {
+                            "name": "Update Processed Recipients",
+                            "type": "ExecuteScript",
+                            "script": `
+const campaignId = context.triggerData._id;
+const emailResult = context.emailResult; 
+
+if (!emailResult || !Array.isArray(emailResult.sent) || emailResult.sent.length === 0) {
+    logger.info('No recipients were successfully sent an email in this chunk.');
+    // Return the original chunk from the first script to allow the condition to check it
+    return { processedChunk: context.result.chunk };
+}
+
+const processedIds = emailResult.sent.map(recipient => recipient._id.toString());
+
+logger.info(\`Updating campaign \${campaignId} with \${processedIds.length} new processed IDs.\`);
+
+await db.update(
+    'campaign',
+    { _id: campaignId },
+    { 'processedRecipients': [...campaign.processedRecipients, ...processedIds] }
+);
+
+// Return the original chunk for the condition check step
+return { processedChunk: context.result.chunk };
+`
+                        },
+                        {
+                            "name": "Set Campaign to 'finished'",
+                            "type": "UpdateData",
+                            "targetModel": "campaign",
+                            "targetSelector": { "_id": "{triggerData._id}" },
+                            "fieldsToUpdate": { "status": "finished" }
+                        }
+                    ],
+                    "workflowStep": [
+                        {
+                            "name": "Start Campaign Processing",
+                            "workflow": { "$link": { "name": "Campaign Emailing Workflow", "_model": "workflow" } },
+                            "actions": { "$link": { "name": "Set Campaign to 'in_progress'", "_model": "workflowAction" } },
+                            "onSuccessStep": { "$link": { "name": "Process Recipient Chunk", "_model": "workflowStep" } }
+                        },
+                        {
+                            "name": "Process Recipient Chunk",
+                            "workflow": { "$link": { "name": "Campaign Emailing Workflow", "_model": "workflow" } },
+                            "actions":
+                                { "$link": { "$or": [
+                                    {"$eq": ["$name", "Get Next Recipient Chunk"]},
+                                    {"$eq": ["$name", "Send Email to Chunk"]},
+                                    {"$eq": ["$name", "Update Processed Recipients"]}
+                                ],"_model": "workflowAction"}},
+                            "onSuccessStep": { "$link": { "name": "Check if Campaign is Complete", "_model": "workflowStep" } }
+                        },
+                        {
+                            "name": "Check if Campaign is Complete",
+                            "workflow": { "$link": { "name": "Campaign Emailing Workflow", "_model": "workflow" } },
+                            "conditions": { "$gt": [{ "$size": {$ifNull:["{context.result.processedChunk}", []]} }, 0] },
+                            "onSuccessStep": { "$link": { "name": "Process Recipient Chunk", "_model": "workflowStep" } },
+                            "onFailureStep": { "$link": { "name": "Finish Campaign", "_model": "workflowStep" } }
+                        },
+                        {
+                            "name": "Finish Campaign",
+                            "workflow": { "$link": { "name": "Campaign Emailing Workflow", "_model": "workflow" } },
+                            "actions": { "$link": { "name": "Set Campaign to 'finished'", "_model": "workflowAction" } },
+                            "isTerminal": true
+                        }
+                    ],
+                    "workflowTrigger": [{
+                        "name": "On Campaign Scheduled",
+                        "workflow": { "$link": { "name": "Campaign Emailing Workflow", "_model": "workflow" } },
+                        "type": "manual",
+                        "onEvent": "DataEdited",
+                        "targetModel": "campaign",
+                        "dataFilter": { "$eq": ["$status", "scheduled"] },
+                        "isActive": true
+                    }],
+                    "env": envSmtp
+                }
+            }
+        },
+        /*
+        {
+            "name": "Social Media Publisher",
+            "description": "Automate your social media presence. This pack provides a workflow to automatically post new blog articles to Twitter and LinkedIn. Requires the 'Website Starter Pack'.",
+            "tags": ["social media", "marketing", "automation", "workflow"],
+            "dependencies": ["Website Starter Pack"],
+            "models": ["workflow", "workflowStep", "workflowAction", "workflowTrigger", "env"],
+            "data": {
+                "all": {
+                    "workflow": [{
+                        "name": "Publish New Blog Post to Socials",
+                        "description": "Automatically posts a link to a new blog post on Twitter and LinkedIn.",
+                        "startStep": {"$link": {"name": "Post on Social Networks", "_model": "workflowStep"}}
+                    }],
+                    "workflowAction": [
+                        {
+                            "name": "Post to Twitter",
+                            "type": "PostToSocialMedia",
+                            "provider": "Twitter",
+                            "content": "📰 New blog post published: {triggerData.title}! Check it out here: https://your-website.com/blog/{triggerData.slug}"
+                        },
+                        {
+                            "name": "Post to LinkedIn",
+                            "type": "PostToSocialMedia",
+                            "provider": "LinkedIn",
+                            "content": "We've just published a new article: '{triggerData.title}'.\n\n{triggerData.summary}\n\nRead the full post on our blog: https://your-website.com/blog/{triggerData.slug}\n#YourIndustry #BlogPost"
+                        }
+                    ],
+                    "workflowStep": [{
+                        "name": "Post on Social Networks",
+                        "workflow": {"$link": {"name": "Publish New Blog Post to Socials", "_model": "workflow"}},
+                        "actions": {
+                            "$link": {
+                                "$or": [
+                                    {"$eq": ["$name", "Post to Twitter"]},
+                                    {"$eq": ["$name", "Post to LinkedIn"]}
+                                ],
+                                "_model": "workflowAction"
+                            }
+                        },
+                        "isTerminal": true
+                    }],
+                    "workflowTrigger": [{
+                        "name": "On New Blog Post Added",
+                        "workflow": {"$link": {"name": "Publish New Blog Post to Socials", "_model": "workflow"}},
+                        "type": "manual",
+                        "onEvent": "DataAdded",
+                        "targetModel": "content",
+                        "dataFilter": {"category": {"$find": {"name": "Blog"}}},
+                        "isActive": true
+                    }],
+                    "env": [
+                        {"name": "TWITTER_API_KEY", "value": "your_key_here"},
+                        {"name": "TWITTER_API_SECRET", "value": "your_secret_here"},
+                        {"name": "LINKEDIN_ACCESS_TOKEN", "value": "your_token_here"}
+                    ]
+                }
+            }
+        },*/
         {
             "name": "E-commerce Starter Kit",
             "description": "Launch your online store in just a few clicks. This pack includes templates for products, orders, and customers, as well as sample data, KPIs, alerts and an order fulfillment workflow (with sending email).",
@@ -55,13 +299,7 @@ export const getAllPacks = async () => {
             "models": ["env", "taxonomy", "product", "productVariant", "brand", "currency", "order", "shipment", "review", "cart", "cartItem", "discount", "workflow", "workflowStep", "workflowAction","workflowRun", "workflowTrigger", "translation", "lang", "kpi", "dashboard", "alert", "return"],
             "data": {
                 "all": {
-                    "env": [
-                        { "name": "SMTP_HOST", "value": "smtp.example.com", "description": "SMTP server host for sending emails." },
-                        { "name": "SMTP_PORT", "value": "587", "description": "SMTP server port." },
-                        { "name": "SMTP_USER", "value": "user@example.com", "description": "Username for SMTP authentication." },
-                        { "name": "SMTP_PASS", "value": "your_smtp_password", "description": "Password for SMTP authentication." },
-                        { "name": "SMTP_FROM", "value": "\"My Store\" <noreply@example.com>", "description": "The 'From' address for outgoing emails." }
-                    ],
+                    "env":envSmtp,
                     "taxonomy": [
                         { "name": "E-commerce", "type": "category" },
                         { "name": "Clothes", "type": "category", "parent": { "$find": { "name": "E-commerce" } } },
@@ -1122,6 +1360,9 @@ export const getAllPacks = async () => {
                     },{
                         name: "GOOGLE_API_KEY",
                         value: "demo"
+                    },{
+                        name: "DEEPSEEK_API_KEY",
+                        value: "demo"
                     }]
                 }
             }

package/test/data.backup.integration.test.js

@@ -10,19 +10,19 @@ import { vi } from 'vitest'
 import {
     createModel,
     insertData
-} from 'data-primals-engine/modules/data';
+} from '../src/index.js';
 
 import {
     modelsCollection as getAppModelsCollection,
-    getCollectionForUser as getAppUserCollection
-} from 'data-primals-engine/modules/mongodb';
+    getCollectionForUser as getAppUserCollection, getCollectionForUser
+} from '../src/modules/mongodb.js';
 import process from "node:process";
 
-import { dumpUserData, loadFromDump } from 'data-primals-engine/modules/data';
+import { dumpUserData, loadFromDump } from '../src/index.js';
 import fs from "node:fs";
 import {initEngine} from "../src/setenv.js";
 
-vi.mock('data-primals-engine/engine', async(importOriginal) => {
+vi.mock('../src/engine', async(importOriginal) => {
     const mod = await importOriginal() // type is inferred
     return {
         ...mod
@@ -88,6 +88,8 @@ afterAll(async () => {
         });
         fs.rmdirSync(backupDir); // Remove the directory itself
     }
+    const coll = await getCollectionForUser(mockUser);
+    await coll.drop()
 });
 
 beforeAll(async () =>{

package/test/data.integration.test.js

@@ -1,20 +1,19 @@
 // __tests__/data.integration.test.js
 import { ObjectId } from 'mongodb';
-import {expect, describe, it, beforeEach, beforeAll, afterAll} from 'vitest';
+import {vi, expect, describe, it, beforeEach, beforeAll, afterAll} from 'vitest';
 import { Config } from '../src/config.js';
-
 import {
     insertData,
     editData,
     deleteData,
-    searchData, installPack, deleteModels, createModel
-} from 'data-primals-engine/modules/data';
+    searchData, installPack, deleteModels, createModel, patchData
+} from '../src/index.js';
 
 import {
     modelsCollection as getAppModelsCollection,
     getCollection,
-    getCollectionForUser as getAppUserCollection
-} from 'data-primals-engine/modules/mongodb';
+    getCollectionForUser as getAppUserCollection, getCollectionForUser
+} from '../src/modules/mongodb.js';
 import {getRandom} from "../src/core.js";
 import {generateUniqueName, initEngine} from "../src/setenv.js";
 
@@ -828,6 +827,8 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             await deleteModels({ name: orderModel.name, _user: user.username });
             await deleteData(productModel.name, {}, user);
             await deleteData(orderModel.name, {}, user);
+            const coll = await getCollectionForUser(user);
+            await coll.drop();
         });
 
         it('should ALLOW inserting data with a valid relation', async () => {
@@ -871,4 +872,5 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             await deleteData(orderModel.name, initialOrder.insertedIds, user);
         });
     });
+
 });

package/test/events.test.js

@@ -1,7 +1,7 @@
 // events.test.js
 import { Event } from '../src/events.js';
 import {vitest} from "vitest";
-import {expect, describe, it, beforeEach, beforeAll, afterAll} from 'vitest';
+import {expect, describe, it, beforeEach} from 'vitest';
 
 describe('Event System', () => {
     beforeEach(() => {

package/test/file.test.js

@@ -1,13 +1,11 @@
-// __tests__/file.integration.test.js
-import { expect, describe, it, beforeEach, afterEach, beforeAll, afterAll, vi } from 'vitest';
+import { expect, describe, it, beforeEach, 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 {getCollection, getUserCollectionName} from "../src/modules/mongodb.js";
 import { Logger } from "../src/gameObject.js";
 import {maxPrivateFileSize} from "../src/constants.js";
 
@@ -46,19 +44,17 @@ beforeAll(async () => {
 
     filesCollection = await getCollection("files");
 });
-describe('File Module Integration Tests', () => {
-    let testUser;
+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
-        testUser = {
-            username: generateUniqueName('testuser'),
-            _user: generateUniqueName('testuser'),
-            userPlan: 'premium',
-            permissions: ['API_UPLOAD_FILE']
-        };
-
         // Nettoyer les collections avant chaque test
         await filesCollection.deleteMany({});
 
@@ -109,8 +105,7 @@ describe('File Module Integration Tests', () => {
             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();
+        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
 
@@ -119,8 +114,7 @@ describe('File Module Integration Tests', () => {
             await expect(addFile(mockFile, testUser)).rejects.toThrow("api.data.storageLimitExceeded");
         });
 
-        it('should throw error when server capacity is insufficient', async ({skip}) => {
-            skip();
+        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 });
 

package/test/import_export.integration.test.js

@@ -1,20 +1,19 @@
-import {expect, describe, it, beforeEach, beforeAll, afterAll, vi} from 'vitest';
+import {expect, describe, it, beforeEach, beforeAll, afterAll, vi, afterEach} 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
-} from 'data-primals-engine/modules/mongodb';
+    getCollectionForUser as getAppUserCollection, getCollectionForUser
+} from '../src/modules/mongodb.js';
 import {sleep} from "data-primals-engine/core";
 import fs from "node:fs";
-import {getUniquePort, initEngine} from "../src/setenv.js";
+import {initEngine} from "../src/setenv.js";
 import {Config} from "../src/index.js";
 
 // --- Données Mock ---
@@ -38,13 +37,9 @@ const impexTestModel = {
 };
 
 // --- Setup de l'environnement de test ---
-let mongod;
-let testDbUri;
-const testDbName = 'testIntegrationDbHO_Impex';
 let testModelsColInstance;
 let testDatasColInstance;
-let engineInstance;
-const port = getUniquePort(); // Port unique pour cette suite de tests
+
 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();
@@ -56,6 +51,21 @@ 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', () => {
 
@@ -80,6 +90,7 @@ describe('Intégration des fonctions d\'Import/Export', () => {
 
     describe('Export de données', () => {
         it('devrait exporter les données en format JSON', async () => {
+
             const res= await exportData({
                 models: [impexTestModel.name],
                 depth: 1
@@ -103,6 +114,7 @@ describe('Intégration des fonctions d\'Import/Export', () => {
 
     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
@@ -114,13 +126,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(5000);
 
             // Vérification directe en base de données
             const importedDocs = await testDatasColInstance.find({
@@ -136,7 +148,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 +160,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(5000);
             // Vérification en base de données
             const importedDocs = await testDatasColInstance.find({
                 _model: impexTestModel.name,
@@ -185,16 +196,16 @@ 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(5000);
             // 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);
     });
 });