@mlagie/sql-connector 2.0.5 → 2.0.7

package/tests/Model.test.js

@@ -1,5 +1,7 @@
 // 1. LES MOCKS EN PREMIER
 const { mockExecute, mockPool } = require('./mysqlMock');
+const connexionManager = require("../src/db/connexion");
+
 jest.mock('@mlagie/logger', () => ({
     logs: jest.fn(),
     error: jest.fn()
@@ -9,6 +11,8 @@ jest.mock('@mlagie/logger', () => ({
 const { Model } = require('../src/models/Model');
 const { Schema } = require('../src/models/Schema');
 const { setConnexion } = require('../src/db/connexion');
+const { sqlTypeMap } = require('../src/utils/sqlTypeMap');
+const util = require("util");
 
 describe('Tests unitaires avec Mock - Model.js (generate_uuid)', () => {
     let testModel;
@@ -52,4 +56,666 @@ describe('Tests unitaires avec Mock - Model.js (generate_uuid)', () => {
         // L'erreur est catchée par votre Model.js, qui log l'erreur et retourne null.
         expect(uuid).toBeNull();
     });
+
+    test("Le constructeur doit empiler le modèle dans pendingModels", () => {
+        const initialLength = Model.pendingModels.length;
+        const testModel = new Model("DummyTable", { schemaDict: {} });
+
+        expect(Model.pendingModels.length).toBe(initialLength + 1);
+        expect(Model.pendingModels[Model.pendingModels.length - 1]).toBe(testModel);
+    });
+
+    test("save() doit générer un INSERT INTO correct", async () => {
+        const pipelineModel = new Model("ProjectPipeline", { schemaDict: {} });
+        mockExecute.mockResolvedValue([{ insertId: 12, affectedRows: 1 }]);
+
+        const payload = { project_id: 3, name: "start_olm", source: "jenkins" };
+        const result = await pipelineModel.save(payload);
+
+        expect(result.insertId).toBe(12);
+        expect(mockExecute).toHaveBeenCalled();
+
+        const sqlGenere = mockExecute.mock.calls[0][0];
+        const valeursGenerees = mockExecute.mock.calls[0][1];
+
+        expect(sqlGenere).toContain("INSERT INTO `ProjectPipeline`");
+        expect(valeursGenerees).toEqual([3, "start_olm", "jenkins"]);
+    });
+
+    test("find() doit retourner une liste d'instances hydratées", async () => {
+        const pipelineModel = new Model("ProjectPipeline", { schemaDict: {} });
+
+        // On mock la réponse sous forme de lignes (rows) renvoyées par mysql2
+        mockExecute.mockResolvedValue([
+            [
+                { id: 1, name: "start_olm", source: "jenkins" },
+                { id: 2, name: "build-job", source: "jenkins" }
+            ]
+        ]);
+
+        const results = await pipelineModel.find({ where: { source: "jenkins" } });
+
+        expect(results).toHaveLength(2);
+        // On vérifie que la ligne a bien été hydratée en tant que ModelInstance
+        expect(results[0]._name).toBe("ProjectPipeline");
+        expect(results[0].name).toBe("start_olm");
+    });
+
+    test("count() doit renvoyer le nombre d'enregistrements", async () => {
+        const pipelineModel = new Model("ProjectPipeline", { schemaDict: {} });
+
+        // Simule le résultat d'un SELECT COUNT(*)
+        mockExecute.mockResolvedValue([[{ count: 5 }]]);
+
+        const total = await pipelineModel.count({ source: "jenkins" });
+        expect(total).not.toBeNull();
+    });
+
+    test("save() doit propager une erreur SQL", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockRejectedValue(new Error("INSERT ERROR"));
+
+        await expect(
+            model.save({ name: "john" })
+        ).rejects.toThrow("INSERT ERROR");
+    });
+
+    test("find() retourne un tableau vide", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockResolvedValue([[]]);
+
+        const result = await model.find();
+
+        expect(result).toEqual([]);
+    });
+
+    test("find() propage une erreur SQL", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockRejectedValue(new Error("SELECT ERROR"));
+
+        await expect(
+            model.find()
+        ).rejects.toThrow("SELECT ERROR");
+    });
+
+    test("find() génère un INNER JOIN", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockResolvedValue([
+            [{ id: 1, name: "john" }]
+        ]);
+
+        await model.find({
+            select: ["id", "name"],
+            join: {
+                table: "roles",
+                on: "`users`.`role_id` = `roles`.`id`"
+            }
+        });
+
+        const sql = mockExecute.mock.calls[0][0];
+
+        expect(sql).toContain("INNER JOIN");
+    });
+
+    test("delete() doit propager une erreur SQL", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockRejectedValue(new Error("DELETE ERROR"));
+
+        await expect(
+            model.delete({ id: 1 })
+        ).rejects.toThrow(Error);
+    });
+
+    test("customRequest() retourne une instance", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockResolvedValue([
+            [{ id: 1 }]
+        ]);
+
+        const result = await model.customRequest(
+            "SELECT * FROM users"
+        );
+
+        expect(result).toBeDefined();
+    });
+
+    test("customRequest() retourne 0 si vide", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockResolvedValue([[]]);
+
+        const result = await model.customRequest(
+            "SELECT * FROM users"
+        );
+
+        expect(result).toBe(0);
+    });
+
+    test("customRequest() propage une erreur SQL", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockRejectedValue(
+            new Error("CUSTOM ERROR")
+        );
+
+        await expect(
+            model.customRequest("SELECT")
+        ).rejects.toThrow("CUSTOM ERROR");
+    });
+
+    test("dropTable() exécute la requête", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockResolvedValue([{}]);
+
+        await model.dropTable();
+
+        expect(mockExecute).toHaveBeenCalled();
+    });
+
+    test("dropTable() propage une erreur SQL", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockRejectedValue(
+            new Error("DROP ERROR")
+        );
+
+        await expect(
+            model.dropTable()
+        ).rejects.toThrow("DROP ERROR");
+    });
+
+    test("generateCreateTableStatement() génère un CREATE TABLE", () => {
+        const model = new Model("users", {
+            schemaDict: {}
+        });
+
+        const sql = model.generateCreateTableStatement({
+            id: {
+                type: Number,
+                primary_key: true
+            }
+        });
+
+        expect(sql).toContain("CREATE TABLE");
+    });
+
+    test("generateCreateTableStatement() refuse SELECT comme nom de table", () => {
+        const model = new Model("SELECT", {
+            schemaDict: {}
+        });
+
+        const result = model.generateCreateTableStatement({
+            id: { type: Number }
+        });
+
+        expect(result).toBeUndefined();
+    });
+
+    test("syncAllTables() traite les modèles en attente", async () => {
+        Model.pendingModels = [];
+
+        new Model("users", {
+            schemaDict: {
+                id: {
+                    type: Number
+                }
+            }
+        });
+
+        mockExecute.mockResolvedValue([{}]);
+
+        await Model.syncAllTables();
+
+        expect(mockExecute).toHaveBeenCalled();
+    });
+
+    test("generateCreateTableStatement() couvre les types spéciaux", () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        const sql = model.generateCreateTableStatement({
+            active: {
+                type: Boolean,
+                default: true
+            },
+            score: {
+                type: "Float",
+                default: 12.5
+            },
+            metadata: {
+                type: Object,
+                default: { test: true }
+            },
+            created_at: {
+                type: Date,
+                default: "CURRENT_TIMESTAMP"
+            }
+        });
+
+        expect(sql).toContain("BOOLEAN");
+        expect(sql).toContain("FLOAT");
+        expect(sql).toContain("JSON");
+        expect(sql).toContain("CURRENT_TIMESTAMP");
+    });
+
+    test("generateCreateTableStatement() refuse les types inconnus", () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        expect(() => {
+            model.generateCreateTableStatement({
+                test: {
+                    type: "BananaType"
+                }
+            });
+        }).toThrow();
+    });
+
+    test("generateCreateTableStatement() couvre field.type qui est une string", () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        const sql = model.generateCreateTableStatement({
+            age: {
+                type: "Number"
+            }
+        });
+
+        expect(sql).toContain("INT");
+    });
+
+    test("generateCreateTableStatement() couvre field.name", () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        const sql = model.generateCreateTableStatement({
+            created_at: Date
+        });
+
+        expect(sql).toContain("DATETIME");
+    });
+
+    test("syncAllTables avec foreign key", async () => {
+        Model.pendingModels = [];
+
+        new Model("roles", {
+            schemaDict: {
+                id: {
+                    type: Number
+                }
+            }
+        });
+
+        new Model("users", {
+            schemaDict: {
+                role_id: {
+                    type: Number,
+                    foreignKey: "roles(id)"
+                }
+            }
+        });
+
+        mockExecute.mockResolvedValue([{}]);
+
+        await Model.syncAllTables();
+
+        expect(mockExecute).toHaveBeenCalled();
+    });
+
+    test("syncAllTables propage les erreurs SQL", async () => {
+        Model.pendingModels = [];
+
+        new Model("users", {
+            schemaDict: {
+                id: {
+                    type: Number
+                }
+            }
+        });
+
+        mockExecute.mockRejectedValue(
+            new Error("CREATE ERROR")
+        );
+
+        await expect(
+            Model.syncAllTables()
+        ).rejects.toThrow("CREATE ERROR");
+    });
+
+    test("ENUM sans type", () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        const sql = model.generateCreateTableStatement({
+            status: {
+                enum: ["OPEN", "CLOSED"]
+            }
+        });
+
+        expect(sql).toContain("status ENUM");
+    });
+
+    test("find conserve les objets select", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockResolvedValue([[{ id: 1 }]]);
+
+        await model.find({
+            select: [
+                {
+                    count: "*",
+                    as: "total"
+                }
+            ]
+        });
+
+        expect(mockExecute).toHaveBeenCalled();
+    });
+    test("delete retourne 1 si suppression", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockResolvedValue([
+            {
+                affectedRows: 1
+            }
+        ]);
+
+        const result = await model.delete({
+            id: 1
+        });
+
+        expect(result).toBe(1);
+    });
+
+    test("generate_uuid retourne un uuid unique", async () => {
+        mockExecute
+            .mockResolvedValueOnce([
+                [{ "UUID()": "uuid-test" }]
+            ])
+            .mockResolvedValueOnce([
+                [{ "COUNT(*)": 0 }]
+            ]);
+
+        const result = await testModel.generate_uuid();
+
+        expect(result).toBe("uuid-test");
+    });
+
+    test("generateCreateTableStatement supporte un constructeur JS", () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        const sql = model.generateCreateTableStatement({
+            created_at: Date
+        });
+
+        expect(sql).toContain("DATETIME");
+    });
+
+    test("default fonction sur un type Date", () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        const sql = model.generateCreateTableStatement({
+            created_at: {
+                type: Date,
+                default: () => new Date()
+            }
+        });
+
+        expect(sql).toContain("DEFAULT CURRENT_TIMESTAMP");
+    });
+
+    test("default Date", () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        const sql = model.generateCreateTableStatement({
+            created_at: {
+                type: Date,
+                default: new Date("2024-01-01T12:00:00Z")
+            }
+        });
+
+        expect(sql).toContain("2024-01-01");
+    });
+
+    test("default avec un symbole", () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        const sql = model.generateCreateTableStatement({
+            test: {
+                type: String,
+                default: Symbol.for("hello")
+            }
+        });
+
+        expect(sql).toContain("hello");
+    });
+
+    test("primary_key et unique sont incompatibles", () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        expect(() =>
+            model.generateCreateTableStatement({
+                id: {
+                    type: Number,
+                    primary_key: true,
+                    unique: true
+                }
+            })
+        ).toThrow();
+    });
+
+    test("enum avec type défini", () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        const sql = model.generateCreateTableStatement({
+            role: {
+                type: String,
+                enum: ["ADMIN", "USER"]
+            }
+        });
+
+        expect(sql).toContain("ENUM");
+    });
+
+    test("save retourne le premier résultat mysql", async () => {
+        const model = new Model("users", { schemaDict: {} });
+
+        mockExecute.mockResolvedValue([
+            {
+                insertId: 123,
+                affectedRows: 1
+            }
+        ]);
+
+        const result = await model.save({
+            name: "john"
+        });
+
+        expect(result).toEqual({
+            insertId: 123,
+            affectedRows: 1
+        });
+    });
+
+    test("generate_uuid retourne un uuid unique", async () => {
+        mockExecute
+            .mockResolvedValueOnce([
+                [{ "UUID()": "uuid-123" }]
+            ])
+            .mockResolvedValueOnce([
+                [{ "COUNT(*)": 0 }]
+            ]);
+
+        const result = await testModel.generate_uuid();
+
+        expect(result).toBe("uuid-123");
+    });
+
+    test("find() - Options Advanced - Doit gérer les jointures de table et ignorer les éléments du select qui ne sont pas des chaînes", async () => {
+        // 1. Initialisation de votre modèle
+        const pipelineModel = new Model("ProjectPipeline", { schemaDict: {} });
+
+        // Simule une réponse MySQL nominale pour que la méthode find() aille jusqu'au bout
+        mockExecute.mockResolvedValue([[{ id: 1 }]]);
+
+        // 2. On configure des options avec un 'join' et un tableau 'select' mixte
+        await pipelineModel.find({
+            select: [
+                "id",             // Chaîne standard (sera préfixée par la table principale)
+                "name_pipeline",  // Chaîne commençant par 'name' (sera préfixée par la table de jointure)
+                12345,            // 🔥 UN NOMBRE (Pas une string) : déclenchera le 'return item' direct
+                { raw: "NOW()" }  // 🔥 UN OBJET (Pas une string) : déclenchera également le 'return item'
+            ],
+            join: {
+                table: "Users",
+                on: { "ProjectPipeline.user_id": "Users.id" }
+            }
+        });
+
+        // 3. Validation de la requête SQL générée en arrière-plan
+        const lastQuery = mockExecute.mock.calls[0][0];
+
+        // Vérifie que les chaînes ont bien été traitées avec leur table respective
+        expect(lastQuery).toContain("`ProjectPipeline`.`id`");
+        expect(lastQuery).toContain("`Users`.`name_pipeline`");
+
+        // Le test passe avec succès et la ligne de couverture "return item" est validée !
+    });
+
+    test("generate_uuid() - Doit renvoyer null si l'UUID généré existe déjà en base de données (Collision)", async () => {
+        // 1. Initialisation de votre modèle
+        const pipelineModel = new Model("ProjectPipeline", { schemaDict: {} });
+
+        // 2. Configuration des réponses successives de la base de données (mocking séquentiel)
+        mockExecute
+            // Premier appel MySQL : La fonction native SELECT UUID(); génère un UUID virtuel
+            .mockResolvedValueOnce([[{ "UUID()": "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d" }]])
+            // Deuxième appel MySQL : La requête de vérification COUNT(*) indique que cet UUID existe déjà (COUNT = 1)
+            .mockResolvedValueOnce([[{ "COUNT(*)": 1 }]]);
+
+        // 3. Exécution de la méthode : comme COUNT(*) vaut 1, la condition == 0 est FAUSSE
+        const uuidResult = await pipelineModel.generate_uuid("uuid_field");
+
+        // 4. Vérification que la méthode a bien retourné null suite à la collision
+        expect(uuidResult).toBeNull();
+
+        // Optionnel : On s'assure que la requête générée ciblait bien le bon champ de condition
+        const lastSqlQuery = mockExecute.mock.calls[1][0];
+        expect(lastSqlQuery).toContain("WHERE `uuid_field` = ?");
+    });
+});
+
+describe("Model Unit Tests - Deep Coverage", () => {
+
+    beforeAll(() => {
+        connexionManager.setConnexion(mockPool);
+    });
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test("getColumnDefinition & formatDefaultSql - Traitement des cas limites et d'erreurs", () => {
+        const myModel = new Model("Users", {});
+
+        // Lignes 92-94 : Conflit Primary Key ET Unique
+        expect(() => {
+            myModel.generateCreateTableStatement({
+                id: { type: "INT", primary_key: true, unique: true }
+            });
+        }).toThrow("Field 'id' cannot be both PRIMARY KEY and UNIQUE.");
+
+        // Formatage de valeurs par défaut exotiques (Fonction date, Date object, Objets complexes)
+        // Note: Pour tester indirectement getColumnDefinition, on l'appelle via generateCreateTableStatement
+        const complexSchema = {
+            created_at: { type: Date, default: () => new Date() }, // Ligne 34
+            updated_at: { type: "Timestamp", default: "NOW()" },        // Ligne 37
+            metadata: { type: Boolean, default: false }       // Ligne 49
+        };
+        const sql = myModel.generateCreateTableStatement(complexSchema);
+        expect(sql).toContain("DEFAULT CURRENT_TIMESTAMP");
+        expect(sql).toContain('CREATE TABLE IF NOT EXISTS `Users` (`created_at` DATETIME DEFAULT CURRENT_TIMESTAMP, `updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP, `metadata` BOOLEAN DEFAULT 0) ENGINE=InnoDB');
+
+        expect(() => {
+            myModel.generateCreateTableStatement({
+                ghost: { type: "UNKNOWN_TYPE" }
+            });
+        }).toThrow("Field ghost has unsupported type UNKNOWN_TYPE."); // Si non bloqué par l'étape 100, l'étape 210 lèvera l'exception d'un type invalide
+    });
+
+    test("syncAllTables() - Gestion nominale de création et détection des cycles de clés étrangères", async () => {
+        Model.pendingModels = []; // On nettoie les modèles empilés
+
+        // Création de deux modèles interdépendants pour forcer la détection cyclique (Ligne 163)
+        const modelA = new Model("TableA", { schemaDict: { b_id: { foreignKey: "TableB(id)" } } });
+        const modelB = new Model("TableB", { schemaDict: { a_id: { foreignKey: "TableA(id)" } } });
+
+        // Ligne 163 : Doit lever une erreur à cause de la boucle TableA -> TableB -> TableA
+        await expect(Model.syncAllTables()).rejects.toThrow("Cyclic foreign key dependency detected");
+
+        // Cas nominal : Nettoyage et ré-empilement de modèles sans cycle
+        Model.pendingModels = [];
+        const modelSingle = new Model("TableNominale", { schemaDict: { id: { type: "Number" } } });
+
+        mockExecute.mockResolvedValue([{ affectedRows: 1 }]);
+        await Model.syncAllTables();
+
+        expect(mockExecute).toHaveBeenCalled();
+    });
+
+    test("generateCreateTableStatement() - Doit rejeter les structures vides et les mots réservés", () => {
+        // Champ sans aucun type défini
+        const modelInvalid = new Model("TestTable", {});
+        expect(() => {
+            modelInvalid.generateCreateTableStatement({ undefined_field: {} });
+        }).toThrow("Field undefined_field has no type defined.");
+
+        // Type invalide ou non supporté passé sous forme de string directe
+        expect(() => {
+            modelInvalid.generateCreateTableStatement({ invalid_field: "BAD_TYPE_STRING" });
+        }).toThrow("Field invalid_field has unsupported type");
+
+        // Utilisation d'un mot-clé réservé SQL comme nom de table (ex: SELECT, ALTER)
+        const modelReserved = new Model("SELECT", {});
+        const result = modelReserved.generateCreateTableStatement({ id: { type: "Number" } });
+        expect(result).toBeUndefined(); // Renvoie undefined car le log d'erreur bloque la requête
+    });
+
+    test("find() - Ligne 259 - Doit intercepter et propager les erreurs SQL", async () => {
+        const myModel = new Model("Users", { schemaDict: {} });
+        mockExecute.mockRejectedValue(new Error("Syntax Error near WHERE"));
+
+        await expect(myModel.find({ select: ["id"] })).rejects.toThrow("Syntax Error near WHERE");
+    });
+
+    test("count() - Ligne 278 - Doit générer la requête COUNT globale sans clause WHERE si aucun filtre n'est fourni", async () => {
+        const myModel = new Model("Users", { schemaDict: {} });
+
+        // Simule un retour valide pour l'instanciation de l'instance
+        mockExecute.mockResolvedValue([[{ count: 42 }]]);
+
+        // On appelle count() sans paramètre (filter = undefined)
+        await myModel.count();
+
+        const sqlRequest = mockExecute.mock.calls[0][0];
+        // La requête ne doit pas avoir de mot clé WHERE attaché
+        expect(sqlRequest).not.toContain("WHERE");
+        expect(sqlRequest).toContain("SELECT COUNT(*) as count FROM `Users`");
+    });
+
+    test("customRequest() - Ligne 295 - Doit lever une exception typée en cas de crash SQL", async () => {
+        const myModel = new Model("Users", { schemaDict: {} });
+        mockExecute.mockRejectedValue(new Error("Table doesn't exist"));
+
+        await expect(myModel.customRequest("SELECT * FROM non_existent", "CRITICAL_GET")).rejects.toThrow("Table doesn't exist");
+    });
+
+    test("dropTable() - Ligne 329 - Doit rejeter la promesse si l'instruction DROP échoue", async () => {
+        const myModel = new Model("Users", { schemaDict: {} });
+        mockExecute.mockRejectedValue(new Error("Lock wait timeout exceeded"));
+
+        await expect(myModel.dropTable()).rejects.toThrow("Lock wait timeout exceeded");
+    });
 });