FreeDatas2HTML/tests/freeDatas2HTMLSpec.ts

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

describe("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 pour afficher les données.",  () =>
        {
            expect(() => { return converter.datasViewElt={  id:"dontExist" }; }).toThrowError(errors.elementNotFound+"dontExist");
        });
        
        it("Ne doit pas générer une erreur s'il y a bien un élément dans la page pour l'id fourni pour afficher les données.", () =>
        {
            expect(() => { return converter.datasViewElt={ id:"datas" }; }).not.toThrowError();
        });

        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.needUrl);
        });

        it("Doit retourner un booléen indiquant si un nombre est naturel ou non.", () =>
        {
           expect(freeDatas2HTML.isNaturalNumber(-1)).toBeFalse(); 
           expect(freeDatas2HTML.isNaturalNumber(1.25)).toBeFalse();
           expect(freeDatas2HTML.isNaturalNumber(0)).toBeTrue();
           expect(freeDatas2HTML.isNaturalNumber(1)).toBeTrue();
        });
        
        it("Doit retourner un booléen indiquant si un nombre est un entier positif ou non.", () =>
        {
           expect(freeDatas2HTML.isPositiveInteger(-1)).toBeFalse(); 
           expect(freeDatas2HTML.isPositiveInteger(1.25)).toBeFalse();
           expect(freeDatas2HTML.isPositiveInteger(0)).toBeFalse();
           expect(freeDatas2HTML.isPositiveInteger(1)).toBeTrue();
        });

        // Filtres :
        it("Ne doit accepter que les sélecteurs pour lesquels un élément a été trouvé dans la page pour l'id fourni.", () =>
        {
            converter.datasSelectors=[{ datasFieldNb:2, id:"selector2" },{ datasFieldNb:3, id:"selector3" }];
            expect(converter.datasSelectors.length).toEqual(1);
            expect(converter.datasSelectors[0].id).toEqual("selector2");
        });
        
        it("Si un séparateur vide est fourni pour un sélecteur, il doit être ignoré.", () =>
        {
            converter.datasSelectors=[{ datasFieldNb:2, id:"selector2", separator:"" }];
            expect(converter.datasSelectors[0].separator).toBeUndefined();
        });

        it("Doit accepter tous les sélecteurs si leurs informations sont valides.", () =>
        {
            converter.datasSelectors=[{ datasFieldNb:0, id:"selector1" },{ datasFieldNb:3, id:"selector2" }];
            expect(converter.datasSelectors.length).toEqual(2);
        });
        
        // Classement des données :
        it("Doit me retourner la fonction associée à une colonne, de manière à ce qu'elle soit utilisable pour comparer deux valeurs.", () =>
        {
             // Fonction volontairement basique, car ce n'est pas la fonction que l'on teste ici, mais le fait que l'on puisse l'utiliser !
             const simpleSort = (a: any, b: any) =>
            {
                if(a < b)
                    return 1;
                else if(a > b)
                    return -1;
                else
                    return 0;
            };
            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]);
        });

        // Pagination :
        it("Doit générer une erreur quand aucun élément n'est fourni pour recevoir le sélecteur de pages, alors que cela est nécessaire.",  () =>
        {
            expect(() => { return converter.pagination={  selectedValue:10 }; }).toThrowError(errors.needPagesSelectorElt);
            expect(() => { return converter.pagination={  options: { displayElement: { id:"paginationOptions" }, values: [10,20] }}; }).toThrowError(errors.needPagesSelectorElt);
        });
        
        it("Doit générer une erreur si l'élément fourni pour recevoir le sélecteur de pages n'existe pas dans le DOM.",  () =>
        {
            expect(() => { return converter.pagination={  selectedValue:10, pages: { displayElement: { id:"dontExist" }} }; }).toThrowError(errors.elementNotFound+"dontExist");
        });

        it("Doit générer une erreur si l'élément fourni pour recevoir le sélecteur de pagination n'existe pas dans le DOM.",  () =>
        {
            expect(() => { return converter.pagination={  options: { displayElement: { id:"dontExist" }, values: [10,20] }, pages: { displayElement: { id:"pages" }}}; }).toThrowError(errors.elementNotFound+"dontExist");
        });

        it("Doit générer une erreur si au moins une des options de pagination proposée n'est pas un entier positif.",  () =>
        {
            expect(() => { return converter.pagination={  options: { displayElement: { id:"paginationOptions" },  values:[0,10,20] }, pages: { displayElement: { id:"pages" }}}; }).toThrowError(errors.needPositiveInteger);
        });
        
        it("Doit générer une erreur si la pagination par défaut n'est pas un entier positif.",  () =>
        {
            expect(() => { return converter.pagination={  selectedValue:0, pages: { displayElement: { id:"pages" }} }; }).toThrowError(errors.needPositiveInteger);
        });
        
        it("Doit générer une erreur si la pagination par défaut  ne fait pas partie des valeurs proposées en option.",  () =>
        {
            expect(() => { return converter.pagination={  selectedValue:15, options: { displayElement: { id:"paginationOptions" },  values:[10,20,50] }, pages: { displayElement: { id:"pages" }}}; }).toThrowError(errors.needPaginationByDefaultBeInOptions);
        });
        
        it("Doit accepter une configuration correcte pour la pagination.",  () =>
        {
            let paginationOk =
            {
                selectedValue:10,
                options:
                {
                    displayElement : { id:"paginationOptions" },
                    values: [10,20,50],
                    name: "Choix de pagination :"
                },
                pages:
                {
                    displayElement : { id:"pages" },
                    name: "Page à afficher :"
                }
            };
            expect(() => { return converter.pagination=paginationOk; }).not.toThrowError();
        });
    });

    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.parseMeta.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 au moins un des deux paramètres nécessaires au fonctionnement n'est pas fourni.", async () =>
        {
            await expectAsync(converter.run()).toBeRejectedWith(new Error(errors.needDatasElt));
            converter.datasViewElt={ id:"datas" };
            await expectAsync(converter.run()).toBeRejectedWith(new Error(errors.needUrl));
        });
        
        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.datasNotFound));
            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();
            let txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual(fixtures.datasHTML);
        });
    });

    describe("Création et action des sélecteurs permettant de filter les données affichées.", () =>
    {
        beforeEach( () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
        });
        
        it("Doit générer une erreur si au moins un des numéros de colonne fournis pour les sélecteurs ne correspond pas à une des colonne du fichier.", async () =>
        {
            converter.datasSelectors=[{ datasFieldNb:0, id:"selector1"},{ datasFieldNb:5, id:"selector2"}]; // il y a bien 5 champs, mais la numérotation commence à 0 :-)
            await expectAsync(converter.run()).toBeRejectedWith(new Error(errors.selectorFieldNotFound));
        });
        
        it("Ne doit pas pas générer d'erreur si tous les numéros de colonne des sélecteurs correspondent à une des colonnes du fichier.", async () =>
        {
            converter.datasSelectors=[{ datasFieldNb:3, id:"selector1"},{ datasFieldNb:4, id:"selector2"}];
            await expectAsync(converter.run()).not.toBeRejected();
        });
        
        it("Pour chaque sélecteur demandé, doit générer un élement <select> listant les valeurs distinctes du fichier, classées dans le bon ordre.", async () =>
        {
            converter.datasSelectors=[{ datasFieldNb:3, id:"selector1"},{ datasFieldNb:4, id:"selector2"}];
            await converter.run();
            expect(document.getElementById("selector1").innerHTML).toEqual(fixtures.selector1HTML);
            expect(document.getElementById("selector2").innerHTML).toEqual(fixtures.selector2HTML);
        });
              
        it("Si des valeurs vides sont présentes dans une colonne utilisée pour un sélecteur, elles doivent être ignorées.", async () =>
        {
            converter.datasSourceUrl="http://localhost:9876/datas/datas1-emtyinfield.csv";
            converter.datasSelectors=[{ datasFieldNb:3, id:"selector1"}];
            await converter.run();
            expect(document.getElementById("selector1").innerHTML).toEqual(fixtures.selector1HTML);
        });
              
        it("Le choix d'une option dans un des sélecteurs doit modifier le contenu du tableau pour ne garder que les données correspondantes et les afficher toutes si sélection 0.", async () =>
        {
            converter.datasSelectors=[{ datasFieldNb:3, id:"selector1"},{ datasFieldNb:4, id:"selector2"}];
            await converter.run();
            let selectElement = document.getElementById("freeDatas2HTMLSelector0") as HTMLInputElement;
            selectElement.value="4";
            selectElement.dispatchEvent(new Event('change'));
            let txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual(fixtures.datasHTMLFor1Select);
            selectElement.value="0";
            selectElement.dispatchEvent(new Event('change'));
            txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual(fixtures.datasHTML);
        });

       it("Si plusieurs sélecteurs sont utilisés, seules les données correspondant à tous ces choix doivent être affichées. Il peut n'y avoir aucun résultat.", async () =>
        {
            converter.datasSelectors=[{ datasFieldNb:3, id:"selector1"},{ datasFieldNb:4, id:"selector2"}];
            await converter.run();
            let selectElement = document.getElementById("freeDatas2HTMLSelector0") as HTMLInputElement;
            selectElement.value="2";
            selectElement = document.getElementById("freeDatas2HTMLSelector1")  as HTMLInputElement;           
            selectElement.value="1";
            selectElement.dispatchEvent(new Event('change'));
            let txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual(fixtures.datasHTMLFor2Select);
            selectElement.value="4";
            selectElement.dispatchEvent(new Event('change'));
            txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual(fixtures.datasHTMLFor2SelectNone);
        });

        // Cas particulier des champs pouvant contenir plusieurs valeurs :
        it("Si un séparateur est fourni pour un sélecteur, les valeurs distinctes extraites de cette colonne doivent le prendre en compte.", async () =>
        {
            converter.datasSourceUrl="http://localhost:9876/datas/datas1+tagsfield.csv";
            converter.datasSelectors=[{ datasFieldNb:5, id:"selector1", separator:"|"}];
            await converter.run();
            expect(document.getElementById("selector1").innerHTML).toEqual(fixtures.selector1HTMLWithTags);
        });
        
        it("Si un séparateur est fourni pour un sélecteur, lorsque qu'une valeur y est sélectionnée, toutes les lignes de données la contenant doivent être affichées.", async () =>
        {
            converter.datasSourceUrl="http://localhost:9876/datas/datas1+tagsfield.csv";
            converter.datasSelectors=[{ datasFieldNb:5, id:"selector1", separator:"|"}];
            await converter.run();
            let selectElement=document.getElementById("freeDatas2HTMLSelector0") as HTMLInputElement;
            selectElement.value="11"; // = "Exemple10" retournant une seule ligne
            selectElement.dispatchEvent(new Event('change'));
            let txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual(fixtures.datasHTMLForSelectTagsField);
        });
        
        it("Les sélecteurs basés sur un séparateur peuvent fonctionner avec un autre filtre.", async () =>
        {
            converter.datasSourceUrl="http://localhost:9876/datas/datas1+tagsfield.csv";
            converter.datasSelectors=[{ datasFieldNb:4, id:"selector1"}, { datasFieldNb:5, id:"selector2", separator:"|"}];
            await converter.run();
            
            let selectElement=document.getElementById("freeDatas2HTMLSelector1") as HTMLInputElement;
            selectElement.value="11"; // = "Exemple10" retournant une seule ligne
            selectElement.dispatchEvent(new Event('change'));
            let txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual(fixtures.datasHTMLForSelectTagsField);
            
            selectElement=document.getElementById("freeDatas2HTMLSelector0") as HTMLInputElement;
            selectElement.value="3"; // doit supprimer la ligne restant
            selectElement.dispatchEvent(new Event('change'));
            txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual("<table><thead><tr><th>Z (numéro atomique)</th><th>Élément</th><th>Symbole</th><th>Famille</th><th>Abondance des éléments dans la croûte terrestre (μg/k)</th><th>Étiquettes</th></tr></thead><tbody></tbody></table>");
        });
    });

    describe("Création et action des colonnes permettant de classer les données affichées.", () =>
    {
        beforeEach( () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
        });
        
        it("Doit générer une erreur si au moins un des numéros de colonne de classement fournis pour ne correspond pas à une des colonne du fichier.", async () =>
        {
            converter.datasSortingColumns=[{ datasFieldNb:0 },{ datasFieldNb:5 }];
            await expectAsync(converter.run()).toBeRejectedWith(new Error(errors.sortingColumnsFieldNotFound));
        });
        
        it("Ne doit pas pas générer d'erreur si tous les numéros de colonne de classement fournis correspondent à des colonnes du fichier.", async () =>
        {
            converter.datasSortingColumns=[{ datasFieldNb:3 },{ datasFieldNb:4 }];
            await expectAsync(converter.run()).not.toBeRejected();
        });
        
        it("Pour chaque colonne de classement demandée, doit générer un lien hypertexte dans l'entête de la colonne.", async () =>
        {
            converter.datasSortingColumns=[{ datasFieldNb:0 },{ datasFieldNb:2 }];
            await converter.run();
            let getTableTr=document.querySelectorAll("table th");
            expect(getTableTr[0].innerHTML).toEqual(fixtures.sortingColumn1HTML);
            expect(getTableTr[2].innerHTML).toEqual(fixtures.sortingColumn2HTML);
        });
                
        it("Le 1er click sur l'entête d'une des colonnes doit classer les données dans le sens ascendant, puis descendant et ainsi de suite, en prenant en compte les éventuels filtres.", async () =>
        {
            converter.datasSelectors=[{ datasFieldNb:3, id:"selector1"},{ datasFieldNb:4, id:"selector2"}];
            converter.datasSortingColumns=[{ datasFieldNb:2 }];
            await converter.run();
            let selectElement = document.getElementById("freeDatas2HTMLSelector0") as HTMLInputElement;
            selectElement.value="2";
            selectElement = document.getElementById("freeDatas2HTMLSelector1")  as HTMLInputElement;           
            selectElement.value="1";
            selectElement.dispatchEvent(new Event('change'));
            let getTableTrLink=document.querySelector("table th a") as HTMLElement;
            getTableTrLink.click();// tri ascendant
            let txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual(fixtures.datasHTMLFor2Select1Clic);
            getTableTrLink.click();// tri descendant
            txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual(fixtures.datasHTMLFor2Select2Clic);
            getTableTrLink.click();// de nouveau ascendant
            txtDatasViewsElt=document.getElementById("datas").innerHTML;
            expect(txtDatasViewsElt).toEqual(fixtures.datasHTMLFor2Select1Clic);
        });
    });

    describe("Création et action des options permettant de paginer les données affichées.", () =>
    {
        beforeEach( () =>
        {
            converter.datasViewElt={ id:"datas" };
            converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
            converter.pagination=
            {
                selectedValue:10,
                options:
                {
                    displayElement : { id:"paginationOptions" },
                    values: [10,20,50,500],
                    name: "Choix de pagination :"
                },
                pages:
                {
                    displayElement : { id:"pages" },
                    name: "Page à afficher :"
                }
            }
        });

        it("Si des options de pagination sont fournies, doit générer un élement <select> listant les valeurs possibles.", async () =>
        {
            await converter.run();
            expect(document.getElementById("paginationOptions").innerHTML).toEqual(fixtures.selectorForPagination);
        });

        it("Si une valeur de pagination par défaut fournie, ne doit pas afficher plus de données.", async () =>
        {
            await converter.run();
            let getTableTr=document.querySelectorAll("tr");// attention, un tr sert aux titres
            expect(getTableTr.length).toEqual(converter.pagination.selectedValue+1);
        });

        it("Si une des options de pagination fournies est sélectionnée, doit afficher la première page de résultats correspondants.", async () =>
        {
            await converter.run();
            let selectElement = document.getElementById("freeDatas2HTMLPaginationSelector") as HTMLInputElement;
            selectElement.value="2"; // = 20 éléments / page
            selectElement.dispatchEvent(new Event('change'));
            let getTableTr=document.querySelectorAll("tr");
            expect(getTableTr.length).toEqual(21);
            selectElement.value="3"; // = 50 éléments / page
            selectElement.dispatchEvent(new Event('change'));
            getTableTr=document.querySelectorAll("tr");
            expect(getTableTr.length).toEqual(51);
            selectElement.value="0"; // = pas de pagination, on affiche les 118 lignes du fichier
            selectElement.dispatchEvent(new Event('change'));
            getTableTr=document.querySelectorAll("tr");
            expect(getTableTr.length).toEqual(119);
        });
        
        it("Si il y a plus de données que le nombre de lignes autorisées par page, un <select> listant les pages doit être affichés.", async () =>
        {
            await converter.run();
            let btnPaginationElt=document.getElementById("pages").innerHTML;
            expect(btnPaginationElt).toEqual(fixtures.selectorForPages);
        });

        it("Si l'utilisateur sélectionne une des pages proposées, l'affichage des résultats doit s'adapter en prenant en compte la pagination sélectionnée.", async () =>
        {
            await converter.run();
            let selectElement = document.getElementById("freeDatas2HTMLPaginationSelector") as HTMLInputElement;
            selectElement.value="3"; // = 50 éléments / page
            selectElement.dispatchEvent(new Event('change'));
            selectElement=document.getElementById("freeDatas2HTMLPagesSelector") as HTMLInputElement;
            selectElement.value="2"; 
            selectElement.dispatchEvent(new Event('change'));
            let getTableTr=document.getElementsByTagName("tr");
            expect(getTableTr[1].innerHTML).toEqual(fixtures.firstLineForPageSelection1);
            expect(getTableTr[50].innerHTML).toEqual(fixtures.lastLineForPageSelection1);
            selectElement.value="3"; // troisième page = incomplèet (18 enregistrements)
            selectElement.dispatchEvent(new Event('change'));
            getTableTr=document.getElementsByTagName("tr");
            expect(getTableTr[1].innerHTML).toEqual(fixtures.firstLineForPageSelection2);
            expect(getTableTr[18].innerHTML).toEqual(fixtures.lastLineForPageSelection2);
        });
    });
});