@mlagie/sql-connector 2.0.7 → 2.0.9

package/tests/ModelInstance.test.js

@@ -1,335 +0,0 @@
-const { ModelInstance } = require("../src/models/ModelInstance");
-// 1. Importez le vrai gestionnaire de connexion de votre ORM
-const connexionManager = require("../src/db/connexion");
-const util = require("util");
-// 2. Définissez votre structure de mock locale
-const mockExecute = jest.fn();
-const mockPool = {
-    promise: () => ({
-        execute: mockExecute
-    })
-};
-
-// Empêche les logs d'erreurs volontaires des tests de polluer le terminal
-jest.mock('@mlagie/logger', () => ({
-    error: jest.fn(),
-    logs: jest.fn(),
-    serveur: jest.fn()
-}));
-
-describe("ModelInstance Unit Tests - v2.0.6", () => {
-
-    beforeAll(() => {
-        // 3. 🔥 LE FIX MAGIQUE : On force l'ORM à utiliser le mock localement
-        // Cela écrase la connexion réelle par votre pool simulé sans dépendre du comportement de jest.mock()
-        connexionManager.setConnexion(mockPool);
-    });
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    test("updateOne() doit exécuter une requête UPDATE valide", async () => {
-        const mockData = { id: 1, name: "callisto-report" };
-        const mockSchema = { schemaDict: { id: { primary_key: true } } };
-        const instance = new ModelInstance("ProjectPipeline", mockData, mockSchema);
-
-        mockExecute.mockResolvedValue([{ affectedRows: 1 }]);
-
-        // Appel de la méthode
-        await instance.updateOne({ name: "nouveau-nom" });
-
-        expect(mockExecute).toHaveBeenCalled();
-    });
-
-    test("Hydratation - _getTargetRow doit gérer un tableau de données imbriqué", () => {
-        // Lignes 47, 52 : Couvre le cas où rows est un tableau de lignes
-        const instance = new ModelInstance("ProjectPipeline", [[{ id: 99, name: "nested" }]]);
-        expect(instance.id).toBe(99);
-    });
-
-    test("updateOne() - Doit lever une erreur et la logger en cas d'échec SQL", async () => {
-        // Lignes 129-130 : Bloc .catch de updateOne
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-        mockExecute.mockRejectedValue(new Error("MySQL Down"));
-
-        await expect(instance.updateOne({ name: "fail" })).rejects.toThrow("MySQL Down");
-    });
-
-    test("delete() - Doit exécuter une suppression groupée et gérer le succès/échec", async () => {
-        // Lignes 138 - 154 : Méthode delete(filter) globale
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-
-        // Cas 1 : Succès avec lignes affectées
-        mockExecute.mockResolvedValue([{ affectedRows: 2 }]);
-        let result = await instance.delete({ status: "old" });
-        expect(result).toBe(1);
-
-        // Cas 2 : Aucune ligne affectée
-        mockExecute.mockResolvedValue([{ affectedRows: 0 }]);
-        result = await instance.delete({ status: "old" });
-        expect(result).toBe(0);
-
-        // Cas 3 : Échec SQL (Couvre le bloc .catch de delete)
-        mockExecute.mockRejectedValue(new Error("Delete Failed"));
-        await expect(instance.delete({ status: "old" })).rejects.toThrow("Delete Failed");
-    });
-
-    test("deleteOne() - Doit lever une erreur en cas d'échec SQL", async () => {
-        // Lignes 173-176 : Bloc .catch de deleteOne
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-        mockExecute.mockRejectedValue(new Error("MySQL Fatal Delete"));
-
-        await expect(instance.deleteOne()).rejects.toThrow("MySQL Fatal Delete");
-    });
-
-    test("customRequest() - Doit exécuter du SQL brut et hydrater ou renvoyer 0", async () => {
-        // Lignes 185-195 : Méthode customRequest
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-
-        // Cas 1 : La requête renvoie des données
-        mockExecute.mockResolvedValue([[{ id: 5, custom_field: "value" }]]);
-        const resData = await instance.customRequest("SELECT * FROM optimization");
-        expect(resData).toBeDefined();
-
-        // Cas 2 : La requête renvoie un tableau vide (Ligne 192 : rows[0].length == 0)
-        mockExecute.mockResolvedValue([[]]);
-        const resEmpty = await instance.customRequest("SELECT * FROM empty");
-        expect(resEmpty).toBe(0);
-
-        // Cas 3 : Échec de la requête (Couvre le bloc .catch de customRequest)
-        mockExecute.mockRejectedValue(new Error("Query Bad Syntax"));
-        await expect(instance.customRequest("SELECT BAD")).rejects.toThrow("Query Bad Syntax");
-    });
-
-    // === COUVRE LIGNES 47, 52 (Setters & Échec JSON.parse) ===
-    test("Hydratation - Doit exécuter les setters dynamiques et capter les faux JSON", () => {
-        const mockData = { id: 1, config: "{malformed json" };
-        const instance = new ModelInstance("ProjectPipeline", mockData);
-
-        // Ligne 52 : Déclenche le setter dynamique (setSafe)
-        instance.id = 45;
-        expect(instance.id).toBe(45);
-    });
-
-    // === COUVRE LIGNES 75-79 (JSON parsing dans getRecordData) ===
-    test("getRecordData - Doit analyser les chaînes JSON ou renvoyer le tableau brut", () => {
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-
-        // On simule une structure où _data est un tableau contenant une chaîne JSON
-        instance._data = ["[{\"id\": 10, \"name\": \"json-extracted\"}]"];
-
-        const record = instance.getRecordData();
-        expect(record).toBeDefined();
-    });
-
-    // === COUVRE LIGNES 99-102 (Extraction de Clé Primaire avec succès) ===
-    test("updateOne() - Doit extraire la clé primaire depuis le dictionnaire de schéma", async () => {
-        const mockData = { id: 77, name: "pipeline-target" };
-        const mockSchema = { schemaDict: { id: { primary_key: true } } };
-        const instance = new ModelInstance("ProjectPipeline", mockData, mockSchema);
-
-        mockExecute.mockResolvedValue([{ affectedRows: 1 }]);
-
-        // Lignes 99-102 : Utilise 'id' comme critère WHERE unique
-        const affected = await instance.updateOne({ name: "pipeline-updated" });
-        expect(affected).toBe(1);
-
-        const sqlGenerated = mockExecute.mock.calls[0][0];
-        expect(sqlGenerated).toContain("UPDATE ProjectPipeline SET `name` = 'pipeline-updated' WHERE `id` = 77");
-    });
-
-    // === COUVRE LIGNES 120-124 (Bloc catch de repli de updateOne) ===
-    test("updateOne() - Doit basculer sur le fallback d'évaluation si le parsing crash", async () => {
-        const mockData = { id: 1, name: "pipeline-fallback-test" };
-        const instance = new ModelInstance("ProjectPipeline", mockData);
-
-        // 🔥 LE FIX : On passe un dictionnaire de schéma structurellement valide (un objet)
-        // mais totalement vide. L'évaluation des clés primaires échouera proprement,
-        // ce qui forcera l'activation du bloc catch de repli (fallback) de updateOne
-        // sans provoquer de panne sur Reflect.get !
-        instance._schema = { schemaDict: {} };
-
-        mockExecute.mockResolvedValue([{ affectedRows: 1 }]);
-
-        // Exécution de la méthode
-        const affected = await instance.updateOne({ status: "patched" });
-        expect(affected).toBe(1);
-
-        const sqlGenerated = mockExecute.mock.calls[0][0];
-        // On valide que le traitement s'est terminé avec succès
-        expect(sqlGenerated).toContain("UPDATE ProjectPipeline SET `status` = 'patched' WHERE `id` = 1 AND `name` = 'pipeline-fallback-test'");
-    });
-
-    // === COUVRE LIGNE 138 (delete avec affectedRows > 0) ===
-    test("delete() - Doit renvoyer 1 si des éléments ont été affectés par la suppression", async () => {
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-
-        // Ligne 138 (Cas affecté)
-        mockExecute.mockResolvedValue([{ affectedRows: 1 }]);
-        const result = await instance.delete({ status: "archived" });
-        expect(result).toBe(1);
-    });
-
-    // === COUVRE LIGNE 178 (deleteOne avec affectedRows > 0) ===
-    test("deleteOne() - Doit renvoyer 1 si l'élément courant a été supprimé", async () => {
-        const instance = new ModelInstance("ProjectPipeline", { id: 200 });
-
-        // Ligne 178 (Cas affecté)
-        mockExecute.mockResolvedValue([{ affectedRows: 1 }]);
-        const result = await instance.deleteOne();
-        expect(result).toBe(1);
-    });
-
-    // === COUVRE LES BLOCS D'ERREURS DÉJÀ EXISTANTS ===
-    test("updateOne() - Doit lever une erreur et la logger en cas d'échec SQL", async () => {
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-        mockExecute.mockRejectedValue(new Error("MySQL Down"));
-
-        await expect(instance.updateOne({ name: "fail" })).rejects.toThrow("MySQL Down");
-    });
-
-    test("delete() - Doit propager l'erreur en cas de rejet SQL", async () => {
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-        mockExecute.mockRejectedValue(new Error("Delete Failed"));
-
-        await expect(instance.delete({ status: "old" })).rejects.toThrow("Delete Failed");
-    });
-
-    test("deleteOne() - Doit lever une erreur en cas d'échec SQL", async () => {
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-        mockExecute.mockRejectedValue(new Error("MySQL Fatal Delete"));
-
-        await expect(instance.deleteOne()).rejects.toThrow("MySQL Fatal Delete");
-    });
-
-    test("customRequest() - Doit exécuter du SQL brut et hydrater ou renvoyer 0", async () => {
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-
-        mockExecute.mockResolvedValue([[{ id: 5, custom_field: "value" }]]);
-        const resData = await instance.customRequest("SELECT * FROM optimization");
-        expect(resData).toBeDefined();
-
-        mockExecute.mockResolvedValue([[]]);
-        const resEmpty = await instance.customRequest("SELECT * FROM empty");
-        expect(resEmpty).toBe(0);
-
-        mockExecute.mockRejectedValue(new Error("Query Bad Syntax"));
-        await expect(instance.customRequest("SELECT BAD")).rejects.toThrow("Query Bad Syntax");
-    });
-
-    test("Getter dynamique - retourne la valeur brute si JSON.parse échoue", () => {
-        const instance = new ModelInstance("ProjectPipeline", {
-            config: "{invalid-json}"
-        });
-
-        expect(instance.config).toBe("{invalid-json}");
-    });
-
-    test("updateOne() met à jour les données locales après succès", async () => {
-        const instance = new ModelInstance(
-            "ProjectPipeline",
-            { id: 1, name: "before" }
-        );
-
-        mockExecute.mockResolvedValue([{ affectedRows: 1 }]);
-
-        await instance.updateOne({ name: "after" });
-
-        expect(instance._data.name).toBe("after");
-    });
-
-    test("updateOne() met à jour le premier élément d'un tableau", async () => {
-        const instance = new ModelInstance(
-            "ProjectPipeline",
-            [{ id: 1, name: "before" }]
-        );
-
-        mockExecute.mockResolvedValue([{ affectedRows: 1 }]);
-
-        await instance.updateOne({ name: "after" });
-
-        expect(instance._data[0].name).toBe("after");
-    });
-
-    test("delete() retourne 0 quand aucune ligne n'est supprimée", async () => {
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-
-        mockExecute.mockResolvedValue([{ affectedRows: 0 }]);
-
-        expect(await instance.delete({ id: 1 })).toBe(0);
-    });
-
-    test("delete() retourne 1 quand une ligne est supprimée", async () => {
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-
-        mockExecute.mockResolvedValue([{ affectedRows: 1 }]);
-
-        expect(await instance.delete({ id: 1 })).toBe(1);
-    });
-
-    test("customRequest() retourne les données hydratées", async () => {
-        const instance = new ModelInstance("ProjectPipeline", { id: 1 });
-
-        mockExecute.mockResolvedValue([
-            [{ id: 123, name: "test" }]
-        ]);
-
-        const result = await instance.customRequest("SELECT * FROM test");
-
-        expect(result).toEqual([{ id: 123, name: "test" }]);
-    });
-
-    test("toJSON() retourne les données locales", () => {
-        const instance = new ModelInstance("ProjectPipeline", { id: 1, name: "test" });
-
-        expect(instance.toJSON()).toEqual({ id: 1, name: "test" });
-    });
-
-    test("updateOne parse une chaîne JSON", async () => {
-        const instance = new ModelInstance(
-            "users",
-            '{"id":1,"name":"john"}'
-        );
-
-        mockExecute.mockResolvedValue([{ affectedRows: 1 }]);
-
-        await instance.updateOne({
-            name: "updated"
-        });
-
-        expect(mockExecute).toHaveBeenCalled();
-    });
-
-    test("updateOne() - Doit basculer sur le bloc catch global et exécuter le fallback", async () => {
-        // 1. On instancie normalement un ModelInstance avec un objet JSON valide
-        const mockData = { id: 10, status: "active" };
-        const instance = new ModelInstance("ProjectPipeline", mockData);
-
-        // 2. On espionne la méthode getRecordData() de cette instance spécifique
-        const spy = jest.spyOn(instance, 'getRecordData');
-
-        // 3. Premier appel (dans le try principal) : On jette une erreur pour forcer le passage au catch
-        // Deuxième appel (dans le bloc catch) : On renvoie l'objet de secours valide mockData
-        spy.mockImplementationOnce(() => {
-            throw new Error("Forced exception to enter catch block");
-        }).mockImplementationOnce(() => {
-            return mockData;
-        });
-
-        // Simule un retour positif de la base de données
-        mockExecute.mockResolvedValue([{ affectedRows: 1 }]);
-
-        // 4. Exécution de la méthode
-        const affected = await instance.updateOne({ status: "patched" });
-
-        expect(affected).toBe(1);
-        expect(mockExecute).toHaveBeenCalled();
-
-        const sqlGenerated = mockExecute.mock.calls[0][0];
-        expect(sqlGenerated).toContain("UPDATE ProjectPipeline SET `status` = 'patched' WHERE `id` = 10 AND `status` = 'active'");
-
-        // 5. On nettoie le spy pour ne pas impacter les autres tests
-        spy.mockRestore();
-    });
-});

package/tests/buildQuery.test.js

@@ -1,217 +0,0 @@
-const { buildSelect, buildQueryParts } = require('../src/utils/buildQuery/buildQuery');
-
-describe('Utils - buildQuery.js', () => {
-    describe('buildSelect', () => {
-        test('Devrait renvoyer "*" si le select est absent ou vide', () => {
-            expect(buildSelect()).toBe('*');
-            expect(buildSelect([])).toBe('*');
-        });
-
-        test('Devrait concaténer les colonnes simples séparées par des retours à la ligne', () => {
-            expect(buildSelect(['id', 'name'])).toBe('`id`,\n`name`');
-        });
-
-        test('Devrait gérer l\'agrégation SUM avec alias optionnel', () => {
-            expect(buildSelect([{ sum: 'price' }])).toBe('SUM(`price`) AS `price`');
-            expect(buildSelect([{ sum: 'price', as: 'total' }])).toBe('SUM(`price`) AS `total`');
-        });
-
-        test('Devrait gérer DATE_FORMAT et appliquer l\'échappement sur la colonne', () => {
-            const select = [{ dateFormat: ['createdAt', '%Y-%m'], as: 'month' }];
-            expect(buildSelect(select)).toBe("DATE_FORMAT(`createdAt`, '%Y-%m') AS `month`");
-        });
-
-        test('Devrait gérer une colonne simple déclarée via un objet avec alias', () => {
-            expect(buildSelect([{ col: 'role', as: 'user_role' }])).toBe('`role` AS `user_role`');
-        });
-    });
-
-    describe('buildQueryParts', () => {
-
-        test('Devrait traiter correctement la clause WHERE sous forme d\'objet structuré (Cas nominal sécurisé)', () => {
-            const options = { where: { status: 'active', role: 'admin' } };
-
-            // L'objet est nettoyé et les colonnes sont échappées avec des backticks
-            expect(buildQueryParts(options)).toEqual("WHERE `status` = 'active' AND `role` = 'admin'");
-        });
-
-        test('Devrait lever une erreur si la clause WHERE est passée sous forme de chaîne brute (Protection Injection SQL)', () => {
-            const optionsInvalides = { where: 'WHERE id = 1 OR 1=1' };
-
-            expect(() => buildQueryParts(optionsInvalides)).toThrow(
-                'Raw string WHERE clauses are not allowed. Use a structured filter instead.'
-            );
-        });
-        test('Devrait traiter la clause WHERE (chaîne brute ou objet)', () => {
-            expect(buildQueryParts({ where: 'id = 1' })).toEqual('WHERE id = 1');
-            expect(buildQueryParts({ where: { status: 'ok' } })).toEqual("WHERE `status` = 'ok'");
-        });
-
-        test('Devrait générer la clause GROUP BY et parser correctement DATE_FORMAT', () => {
-            const options = { groupBy: ['role', "DATE_FORMAT(createdAt, '%Y')"] };
-            expect(buildQueryParts(options)).toEqual("GROUP BY `role`, DATE_FORMAT(`createdAt`, '%Y')");
-        });
-
-        test('Devrait lever une erreur si la clause HAVING est passée sous forme de chaîne brute', () => {
-            expect(() => buildQueryParts({ having: 'count > 1' })).toThrow(
-                'Raw string HAVING clauses are not allowed. Use a structured filter instead.'
-            );
-        });
-
-        test('Devrait traiter la clause ORDER BY (chaîne simple ou objet structuré)', () => {
-            const options = {
-                orderBy: ['name', { field: 'id', direction: 'DESC' }]
-            };
-            expect(buildQueryParts(options)).toEqual('ORDER BY `name`, `id` DESC');
-        });
-
-        test('Devrait accepter la clause LIMIT si elle est un entier valide', () => {
-            expect(buildQueryParts({ limit: 10 })).toEqual("LIMIT 10");
-            expect(buildQueryParts({ limit: 0 })).toEqual("");
-        });
-
-        test('Devrait lever une erreur si la clause LIMIT est invalide', () => {
-            expect(() => buildQueryParts({ limit: -5 })).toThrow('Invalid LIMIT value');
-            expect(() => buildQueryParts({ limit: 10.5 })).toThrow('Invalid LIMIT value');
-            expect(() => buildQueryParts({ limit: 'abc' })).toThrow('Invalid LIMIT value');
-        });
-    });
-    describe('buildQuery - Advanced Fields & Aggregations', () => {
-
-        test('Should safely compile COUNT(*) aggregated calculations with an expression alias', () => {
-            const fields = [{ count: '*', as: 'total_user' }];
-            expect(buildSelect(fields)).toBe('COUNT(*) AS `total_user`');
-        });
-
-        test('Should safely compile COUNT(column) on structured column identifiers', () => {
-            const fields = [{ count: 'id', as: 'unique_ids' }];
-            expect(buildSelect(fields)).toBe('COUNT(`id`) AS `unique_ids`');
-        });
-
-        test('Should correctly process multi-column GROUP BY arrays to avoid ONLY_FULL_GROUP_BY validation issues', () => {
-            const options = {
-                select: ['status', 'email', { count: '*', as: 'total_user' }],
-                groupBy: ['status', 'email']
-            };
-            const parts = buildQueryParts(options);
-
-            expect(parts).toContain('GROUP BY `status`, `email`');
-        });
-
-        test("COUNT DISTINCT sur plusieurs colonnes", () => {
-            expect(
-                buildSelect([
-                    {
-                        count: ["truc", "bidule"],
-                        as: "total"
-                    }
-                ])
-            ).toBe("COUNT(`truc`) + COUNT(`bidule`) AS `total`");
-        });
-
-        test("COUNT conditionnel avec NULL", () => {
-            expect(
-                buildSelect([
-                    {
-                        count: {
-                            truc: null
-                        },
-                        as: "total"
-                    }
-                ])
-            ).toBe("COUNT(CASE WHEN `truc` = NULL THEN 1 END) AS `total`");
-        });
-
-        test("COUNT conditionnel avec NOT NULL", () => {
-            expect(
-                buildSelect([
-                    {
-                        count: {
-                            truc: "NOT NULL"
-                        },
-                        as: "total"
-                    }
-                ])
-            ).toBe("COUNT(CASE WHEN `truc` = 'NOT NULL' THEN 1 END) AS `total`");
-        });
-
-        test("COUNT refuse un nombre", () => {
-            expect(() =>
-                buildSelect([
-                    {
-                        count: 1515
-                    }
-                ])
-            ).toThrow(
-                "Invalid field type for COUNT. Must be a string, array, or object."
-            );
-        });
-
-    });
-
-    describe("buildQuery - buildGroupByItem", () => {
-        test('Return directly an error if group is not a string.', () => {
-            const options = {
-                select: ['status', 'email', { count: '*', as: 'total_user' }],
-                groupBy: ['status', 1255]
-            };
-
-            expect(() => buildQueryParts(options)).toThrow(
-                "Group by items must be strings"
-            );
-        })
-    })
-
-    test('Devrait gérer DISTINCT avec alias', () => {
-        const fields = [
-            {
-                distinct: 'email',
-                as: 'unique_email'
-            }
-        ];
-
-        expect(buildSelect(fields))
-            .toBe('DISTINCT `email` AS `unique_email`');
-    });
-
-    test("GROUP BY simple", () => {
-        expect(
-            buildQueryParts({
-                groupBy: ["status"]
-            })
-        ).toBe("GROUP BY `status`");
-    });
-
-    test("count simple", () => {
-        expect(
-            buildSelect([
-                { count: "id" }
-            ])
-        ).toBe("COUNT(`id`)");
-    });
-
-
-    test("buildSelect supporte *", () => {
-        expect(
-            buildSelect(["*"])
-        ).toBe("*");
-    });
-
-    test("SUM sans alias génère un alias automatique", () => {
-        expect(
-            buildSelect([
-                {
-                    sum: "price"
-                }
-            ])
-        ).toBe("SUM(`price`) AS `price`");
-    });
-
-    test("LIMIT décimal invalide", () => {
-        expect(() =>
-            buildQueryParts({
-                limit: 10.5
-            })
-        ).toThrow();
-    });
-});

package/tests/connect.test.js

@@ -1,44 +0,0 @@
-// 1. CHARGER LE MOCK EN PREMIER
-const { mockPool, mockEnd } = require('./mysqlMock');
-
-// 2. CHARGER LES MODULES DU PROJET ENSUITE
-const { connect, logout } = require('../src/db/connect'); // Ajustez le chemin vers votre dossier src
-const { getConnexion } = require('../src/db/connexion');
-const mysql = require('mysql2');
-
-describe("Tests unitaires avec Mock - connect.js", () => {
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    test("connect() devrait créer un pool mysql2 et définir la connexion globale", async () => {
-        const config = { host: 'localhost', user: 'root', database: 'test' };
-
-        await connect(config);
-
-        // Maintenant mysql.createPool est bien un mock Jest !
-        expect(mysql.createPool).toHaveBeenCalledWith(config);
-        expect(getConnexion()).toBe(mockPool);
-    });
-
-    test("logout() devrait fermer proprement la connexion du pool", async () => {
-        // On simule une connexion active d'abord
-        const { setConnexion } = require('../src/db/connexion');
-        setConnexion(mockPool);
-
-        await logout();
-
-        expect(mockEnd).toHaveBeenCalled();
-    });
-
-    test("logout() doit gérer une erreur lors de la fermeture", async () => {
-        mockPool.end.mockImplementation((callback) => {
-            callback(new Error("Close Error"));
-        });
-
-        await logout();
-
-        expect(mockPool.end).toHaveBeenCalled();
-    });
-});

package/tests/formatObject.test.js

@@ -1,46 +0,0 @@
-const formatObject = require('../src/utils/formatObject');
-
-describe('Utils - formatObject.js', () => {
-    test('Devrait convertir les instances de Date au format DATETIME MySQL local', () => {
-        const date = new Date('2026-07-03T12:34:56.789Z');
-        const result = formatObject({ createdAt: date });
-        expect(result.createdAt).toBe('2026-07-03 12:34:56');
-    });
-
-    test('Devrait supprimer les quotes enveloppantes des chaînes de caractères', () => {
-        const result = formatObject({
-            single: "'hello'",
-            double: '"world"',
-            normal: 'text'
-        });
-        expect(result.single).toBe('hello');
-        expect(result.double).toBe('world');
-        expect(result.normal).toBe('text');
-    });
-
-    test('Devrait déséchapper les quotes protégées d’une chaîne', () => {
-        const result = formatObject({ text: "John\\'s corporate \\\"value\\\"" });
-        expect(result.text).toBe('John\'s corporate "value"');
-    });
-
-    test('Devrait sérialiser les objets imbriqués en JSON et échapper les single quotes', () => {
-        const result = formatObject({ meta: { role: "owner's", active: true } });
-        // L'objet devient une chaîne JSON avec les single quotes échappées par un double antislash
-        expect(result.meta).toBe('{"role":"owner\\\'s","active":true}');
-    });
-
-    test('Devrait ignorer et laisser inchangés les types primitifs non ciblés (nombres, booléens)', () => {
-        const result = formatObject({ age: 25, isValid: true });
-        expect(result.age).toBe(25);
-        expect(result.isValid).toBe(true);
-    });
-
-    test("formatObject couvre hasOwnProperty", () => {
-        const parent = { test: 1 };
-        const obj = Object.create(parent);
-
-        obj.name = "john";
-
-        formatObject(obj);
-    });
-});