FreeDatas2HTML/tests/freeDatas2HTMLSpec.ts

import { FreeDatas2HTML, Selector } 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 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();
        });
        
        // 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.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 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 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 le classement 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);
        });

         /*       Désactivation des tests liés aux filtres avant mises à jour
        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);
        });
    });
});