FreeDatas2HTML/tests/freeDatas2HTMLSpec.ts

import { FreeDatas2HTML, Render} from "../src/freeDatas2HTML";
const errors=require("../src/errors.js");
const fixtures=require("./fixtures.js");

describe("Test du script central de FreeDatas2HTML", () =>
{
    let converter: FreeDatas2HTML;
    
    beforeEach( () =>
    {
        converter=new FreeDatas2HTML();
        document.body.insertAdjacentHTML('afterbegin', fixtures.datasViewEltHTML);
    });

    afterEach( () =>
    {
        document.body.removeChild(document.getElementById('fixture'));
    });

    it("Doit avoir créé une instance de FreeDatas2HTML",  () =>
    {
        expect(converter).toBeInstanceOf(FreeDatas2HTML);
    });

    describe("Test des données de configuration reçues.",  () =>
    {
       it("Doit générer une erreur s'il n'y a pas d'élément dans la page pour l'id fourni.",  () =>
        {
            expect(() => { return FreeDatas2HTML.checkInDOMById({  id:"dontExist" }); }).toThrowError(errors.converterElementNotFound+"dontExist");
        });
        
       it("S'il y a bien un élément dans la page pour l'id fourni, doit retourner l'élement DOM complété.",  () =>
        {
            const eltInDOM=document.getElementById("datas");
            const checkElt=FreeDatas2HTML.checkInDOMById({  id:"datas" });
            expect(checkElt).toEqual({ id:"datas", eltDOM: eltInDOM });
        });
        
        it("Doit générer une erreur si l'url fournie pour le fichier de données est vide.", () =>
        {
            expect(() => { return converter.datasSourceUrl="  "; }).toThrowError(errors.parserNeedUrl);
        });
        
       it("Doit retourner false si un numéro de champ n'est pas trouvé dans les données.", async () =>
        {
            let check=converter.checkFieldExist(2);// aucune donnée chargée, donc le champ ne peut être trouvé
            expect(check).toBeFalse();
            converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
            await converter.parse();
            check=converter.checkFieldExist(-2);
            expect(check).toBeFalse();
            check=converter.checkFieldExist(1.1);
            expect(check).toBeFalse();
            check=converter.checkFieldExist(10);
            expect(check).toBeFalse();
        });
        
       it("Doit retourner true si un numéro de champ a bien été trouvé dans les données.", async () =>
        {
            converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
            await converter.parse();
            let check=converter.checkFieldExist(0);
            expect(check).toBeTrue();
            check=converter.checkFieldExist(2);
            expect(check).toBeTrue();
        });

        it("Doit générer une erreur si une fonction est associée à un champ n'existant pas dans les données.", async () =>
        {
             const simpleSort = (a: any, b: any) =>
            {
                if(a < b)
                    return 1;
                else if(a > b)
                    return -1;
                else
                    return 0;
            };
            expect(() => { return converter.datasSortingFunctions=[{ datasFieldNb:0, sort:simpleSort }]; }).toThrowError(errors.converterFieldNotFound); // données non chargées
            converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
            await converter.parse();
           expect(() => { return converter.datasSortingFunctions=[{ datasFieldNb:10, sort:simpleSort }]; }).toThrowError(errors.converterFieldNotFound); 
        });
        
        it("Doit accepter le fonction associée à un champ, de manière à ce qu'elle soit utilisable pour comparer deux valeurs.", async () =>
        {
             const simpleSort = (a: any, b: any) =>
            {
                if(a < b)
                    return 1;
                else if(a > b)
                    return -1;
                else
                    return 0;
            };
           converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
            await converter.parse();     
            converter.datasSortingFunctions=[{ datasFieldNb:0, sort:simpleSort }];
            expect(converter.getSortingFunctionForField(0)).toBeDefined();
            expect([7,9,3,5].sort(converter.getSortingFunctionForField(0).sort)).toEqual([9,7,5,3]);
        });
    });

    describe("Parsage du fichier et création du tableau de données", () =>
    {
        it("Doit générer une erreur si la lecture du fichier échoue.", async () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/dontExist.csv";
           await expectAsync(converter.parse()).toBeRejectedWith(new Error(errors.parserFail));
        });
        
        it("Doit enregistrer la liste des erreurs rencontrées en parsant le fichier.", async () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/datas-errors1.csv";
            await converter.parse();
            expect(converter.parseErrors.length).toBeGreaterThan(0);
        });
        
        it("Ne doit garder que les noms de colonne non vides.", async () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/datas-errors2.csv";
            await converter.parse();
            expect(converter.parseMetas.fields.length).toEqual(5);
        });
        
        it("Ne doit enregistrer aucune erreur de lecture si le fichier est ok.", async () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
            await converter.parse();
            expect(converter.parseErrors.length).toEqual(0);
        });

        it("Doit générer une erreur si lancé sur url fournie pour le fichier de données.", async () =>
        {
            await expectAsync(converter.run()).toBeRejectedWith(new Error(errors.parserNeedUrl));
        });
        
        it("Ne doit pas générer d'erreur si les deux paramètres fournis sont ok.", async () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
            await expectAsync(converter.run()).toBeResolved();
        }); 

        it("Doit générer une erreur si aucune donnée n'a été trouvée dans le fichier et ne rien afficher dans l'emplacement prévu pour les données.", async () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/nodatas.csv";
            await expectAsync(converter.run()).toBeRejectedWith(new Error(errors.parserDatasNotFound));
            let txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual("");
        });
        
        it("Si la moindre erreur est rencontrée durant la parsage et que cela est demandé, ne rien afficher dans l'emplacement prévu pour les données.", async () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/datas-errors1.csv";
            converter.stopIfParseErrors=true;
            await converter.run();
            let txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual("");
        });
        
        it("Sauf si cela est demandé, les données trouvées dans le fichier seront affichées même si des erreurs sont rencontrées durant la parsage.", async () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/datas-errors1.csv";
            await converter.run();
            let txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).not.toEqual("");
        });

        it("Doit afficher un tableau correspondant aux données du fichier csv", async () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
            await converter.run();
            const render=new Render(converter);
            const htmlForDatas=render.rend2HTML(converter.parseDatas);
             // On ne peut comparer directement au contenu du DOM,
             // car le navigateur change certains caractères (exemple : ">" devient "&gt;")
            expect(converter.datasHTML).toEqual(htmlForDatas);
            // Mais le code commence tout de même par <table> :
            const txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt.indexOf("<table>")).toEqual(0);
            // Et on doit retrouver le bon nombre de lignes :
            const getTR=document.getElementsByTagName("tr");
            expect(getTR.length).toEqual(119);
        });

        it("Si demandé, doit afficher le nombre de lignes de données du fichier.", async () =>
        {
            converter.datasViewElt={ id:"datas" };            
            converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
            converter.datasCounter={ id:"counter" };
            await converter.run();
            let txtDatasViewsElt=document.getElementById("counter").innerHTML;
            expect(txtDatasViewsElt).toEqual("118");
        });
    });
});