FreeDatas2HTML/tests/paginationSpec.ts

import { FreeDatas2HTML, Pagination } from "../src/freeDatas2HTML";

const errors=require("../src/errors.js");
const fixtures=require("./fixtures.js");

describe("Test de la pagination.", () =>
{
    let converter: FreeDatas2HTML;
    let pagination: Pagination;
    
    beforeEach( async () =>
    {
        document.body.insertAdjacentHTML("afterbegin", fixtures.datasViewEltHTML);
        converter=new FreeDatas2HTML();
        converter.datasViewElt={  id:"datas" };
        converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
        await converter.parse();
        pagination=new Pagination(converter, { id:"pages" }, "Page à afficher :");
    });

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

    describe("Test des options de pagination.",  () =>
    {
        it("Doit retourner un booléen indiquant si un nombre est un entier positif ou non.", () =>
        {
           expect(Pagination.isPositiveInteger(-1)).toBeFalse(); 
           expect(Pagination.isPositiveInteger(1.25)).toBeFalse();
           expect(Pagination.isPositiveInteger(0)).toBeFalse();
           expect(Pagination.isPositiveInteger(1)).toBeTrue();
        });

        it("Doit générer une erreur si la pagination est initialisée sans données à traiter.",  () =>
        {
            converter=new FreeDatas2HTML();
            expect(() => { return new Pagination(converter, { id:"pages" }); }).toThrowError(errors.paginationNeedDatas);
        });
                
        it("Doit générer une erreur si initialisé en fournissant l'id d'un élément n'existant pas pour recevoir la liste des pages.",  () =>
        {
            expect(() => { return new Pagination(converter, { id:"dontExist" }); }).toThrowError(errors.elementNotFound+"dontExist");
        });
        
        it("Ne doit pas générer d'erreur si initialisé correctement",  () =>
        {
            expect(() => { return new Pagination(converter, { id:"pages" }); }).not.toThrowError();
        });

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

        it("Doit générer une erreur si les options de pagination sont initialisées avec un tableau de valeurs vide.",  () =>
        {
            expect(() => { return pagination.options={ displayElement: { id:"paginationOptions" }, values: [] }; }).toThrowError(errors.needPaginationOptionsValues);
        });
        
        it("Doit générer une erreur si au moins une des options de pagination fournies n'est pas un entier positif.",  () =>
        {
            expect(() => { return pagination.options={ displayElement: { id:"paginationOptions" }, values: [0,10,20] }; }).toThrowError(errors.needPositiveInteger);
        });

        it("Ne doit pas générer d'erreur si les options de pagination fournies sont correctes.",  () =>
        {
            const test={ displayElement: { id:"paginationOptions" }, values: [10,20,50], name: "La pagination" };
            expect(() => { return pagination.options=test}).not.toThrowError();
            expect(pagination.options).toEqual(test);
        });
                
        it("Doit générer une erreur si la pagination par défaut n'est pas un entier positif.",  () =>
        {
            expect(() => { return pagination.selectedValue=0; }).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.",  () =>
        {
            pagination.options={ displayElement: { id:"paginationOptions" }, values: [10,20,50] };
            expect(() => { return pagination.selectedValue=15; }).toThrowError(errors.needPaginationByDefaultBeInOptions);
        });
        
        it("Doit accepter une pagination par défaut correcte, avec ou sans options proposées.",  () =>
        {
            expect(() => { return pagination.selectedValue=10; }).not.toThrowError();
            pagination.options={ displayElement: { id:"paginationOptions" }, values: [10,20,50] };
            expect(() => { return pagination.selectedValue=10; }).not.toThrowError();
        });
    });

    describe("Création et action des sélecteurs liés à la pagination des données.", () =>
    {
        beforeEach( async () =>
        {
            pagination.options={ displayElement: { id:"paginationOptions" }, values: [10,20,50,500] , name: "Choix de pagination :" };
            pagination.selectedValue=10; // revoir car n'est pas testé si déclaré avant les options
            pagination.rend2HTML();
            converter.pagination=pagination;
            await converter.run();
        });

        it("Si des options de pagination sont fournies, doit générer un élement <select> listant les valeurs possibles.",  () =>
        {            
            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.",  () =>
        {
            let getTR=document.getElementsByTagName("tr");
            expect(getTR.length).toEqual(pagination.selectedValue+1); // 1er TR sert aux titres
        });

        it("Si une des options de pagination fournies est sélectionnée, doit afficher le nombre de résultats correspondants.",  () =>
        {
            let selectElement=document.getElementById("freeDatas2HTMLPaginationSelector") as HTMLInputElement;
            selectElement.value="2"; // = 20 éléments / page
            selectElement.dispatchEvent(new Event('change'));
            let getTR=document.getElementsByTagName("tr");
            expect(getTR.length).toEqual(21);
            selectElement.value="3"; // = 50 éléments / page
            selectElement.dispatchEvent(new Event('change'));
            getTR=document.getElementsByTagName("tr");
            expect(getTR.length).toEqual(51);
            selectElement.value="0"; // = pas de Pagination, on affiche les 118 lignes du fichier
            selectElement.dispatchEvent(new Event('change'));
            getTR=document.getElementsByTagName("tr");
            expect(getTR.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é.", () =>
        {
            let selectElement=document.getElementById("pages").innerHTML;
            expect(selectElement).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.", () =>
        {
            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 getTR=document.getElementsByTagName("tr");
            expect(getTR[1].innerHTML).toEqual(fixtures.firstLineForPageSelection1);
            expect(getTR[50].innerHTML).toEqual(fixtures.lastLineForPageSelection1);
            selectElement.value="3"; // troisième page = incomplète (18 enregistrements)
            selectElement.dispatchEvent(new Event('change'));
            getTR=document.getElementsByTagName("tr");
            expect(getTR[1].innerHTML).toEqual(fixtures.firstLineForPageSelection2);
            expect(getTR[18].innerHTML).toEqual(fixtures.lastLineForPageSelection2);
            expect(getTR[50]).toBeUndefined();
        });
        
    });
    
});