FreeDatas2HTML/tests/selectorSpec.ts

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

describe("Test des sélecteurs de données", () =>
{
    let converter: FreeDatas2HTML;
    let selector: Selector;
    let selectElement : HTMLInputElement;
    
    beforeEach( async () =>
    {
        document.body.insertAdjacentHTML("afterbegin", fixtures.datasViewEltHTML);
        converter=new FreeDatas2HTML("CSV");
        converter.parser.setRemoteSource({ url:"http://localhost:9876/datas/datas1.csv" });
        converter.datasViewElt={  id:"datas" };
        await converter.run();
    });

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

    describe("Test des données de configuration.",  () =>
    {
        it("Doit générer une erreur, si initialisé sans avoir au préalable charger des données.", async () =>
        {
            // Convertisseur non lancé :
            converter=new FreeDatas2HTML("CSV");
            expect(() => { return  new Selector(converter, 0, { id:"selector1" }); }).toThrowError(errors.filterNeedDatas);
            // Note : les parseurs vont générer une erreur en amont s'ils ne trouvent pas de noms de champs.
            // Par contre, ils acceptent de ne pas trouver de données :
            converter.parser.datas2Parse="Z (numéro atomique),Élément,Symbole,Famille,Abondance des éléments dans la croûte terrestre (μg/k)";
            await converter.run();
            expect(() => { return  new Selector(converter, 0, { id:"selector1" }); }).toThrowError(errors.filterNeedDatas);
        });
        
         it("Doit générer une erreur, si le numéro de champ fourni n'existe pas dans les données.", () =>
        {
            expect(() => { return  new Selector(converter, 9, { id:"selector1" }); }).toThrowError(errors.selectorFieldNotFound);
            expect(() => { return  new Selector(converter, -1, { id:"selector1" }); }).toThrowError(errors.selectorFieldNotFound);
            expect(() => { return  new Selector(converter, 1.1, { id:"selector1" }); }).toThrowError(errors.selectorFieldNotFound);
        });
           
        it("Si un séparateur vide est fourni pour un filtre, il doit être ignoré.", () =>
        { 
            selector=new Selector(converter, 0, { id:"selector1" }, "");
            expect(selector.separator).toBeUndefined();
        });

        it("Si toutes les paramètres sont correctes, ils doivent être acceptés.", () =>
        {
            expect(() => { selector=new Selector(converter, 2, { id:"selector1" }, ","); return  true; }).not.toThrowError();
            expect(selector.datasFieldNb).toEqual(2);
            expect(selector.datasViewElt).toEqual({ id:"selector1", eltDOM:document.getElementById("selector1") });
            expect(selector.separator).toEqual(",");
        });
    });

    describe("Création des sélecteurs.", () =>
    {
        beforeEach( async () =>
        {
            selector=new Selector(converter, 3, { id:"selector1" });
        });
        
        it("Doit générer un élement <select> listant les valeurs distinctes du champ spécifié, classées dans le bon ordre.",  () =>
        {
            selector.filter2HTML();            
            expect(document.getElementById("selector1").innerHTML).toEqual(fixtures.selector1HTML);
            selector=new Selector(converter, 4, { id:"selector2" });
            selector.filter2HTML();
            expect(document.getElementById("selector2").innerHTML).toEqual(fixtures.selector2HTML);
        });
        
        it("Doit prendre en compte l'éventuel label fourni pour le SELECT.",  () =>
        {
            selector=new Selector(converter, 4, { id:"selector2" });
            selector.filter2HTML("Abondance des éléments");
            expect(document.getElementById("selector2").innerHTML).toEqual(fixtures.selector2HTMLWithLabel);
        });
        
        it("Si des valeurs vides sont présentes dans une champ utilisé pour un sélecteur, elles doivent être ignorées.", async () =>
        {
            selector.converter.parser.setRemoteSource({ url:"http://localhost:9876/datas/datas1-emtyinfield.csv" });
            await selector.converter.run();
            selector.filter2HTML();   
            expect(document.getElementById("selector1").innerHTML).toEqual(fixtures.selector1HTML);
        });
        
        it("Si des espaces entourent certaines valeurs pour ce champ, ils doivent être supprimés.", async () =>
        {
            selector.converter.parser.setRemoteSource({ url:"http://localhost:9876/datas/datasNeedTrim.csv" });
            await selector.converter.run();
            selector.filter2HTML();
            expect(document.getElementById("selector1").innerHTML).toEqual(fixtures.selectorHTMLWithTrim);
        });

        it("Si un séparateur est fourni, les valeurs distinctes extraites de ce champ doivent le prendre en compte.", async () =>
        {
            converter.parser.setRemoteSource({ url:"http://localhost:9876/datas/datas1+tagsfield.csv" });
            await converter.run();
            selector=new Selector(converter, 5, { id:"selector1" }, "|");
            selector.filter2HTML(); 
            expect(document.getElementById("selector1").innerHTML).toEqual(fixtures.selector1HTMLWithSeparator);
        });
        
        it("Si une fonction spécifique est fournie pour le champ utilisé pour ce filtre, elle doit être prise en compte.",  () =>
        {
            const mySort=(a: any, b: any, order: "asc"|"desc"="asc") =>
            {
                const values=[ "> 100000", "> 1 et < 100 000", "≤ 1",  "Traces", "Inexistant"];
                if(order === "desc")
                    values.reverse();
                if(values.indexOf(a) > values.indexOf(b))
                    return -1;
                else if(values.indexOf(a) < values.indexOf(b))
                    return 1;
                else
                    return 0;
            };            
            converter.datasSortingFunctions=[{ datasFieldNb: 4, sort:mySort }];
            selector=new Selector(converter, 4, { id:"selector1" });
            selector.filter2HTML();
            expect(document.getElementById("selector1").innerHTML).toEqual(fixtures.selector1HTMLWithFunction);
        });

         it("Doit générer une erreur, si aucune donnée n'a été trouvée pour créer le <SELECT>.", async () =>
        {
            selector.converter.parser.setRemoteSource({ url:"http://localhost:9876/datas/datasEmptyField.csv" });
            await selector.converter.run();
            expect(() => { return  selector.filter2HTML(); }).toThrowError(errors.selectorFieldIsEmpty);
        });
    });
           
    describe("Manipulation des sélecteurs et filtre des données.", () =>
    {        
        beforeEach( async () =>
        {
            selector=new Selector(converter, 3, { id:"selector1" }); // filtre sur le champ "famille"
            selector.filter2HTML();
            selectElement=document.getElementById("freeDatas2HTML_selector1") as HTMLInputElement;
        });

        it("La manipulation d'un sélecteur doit enregistrer la valeur sélectionnée et appeler la fonction actualisant l'affichage.",  () =>
        {
            spyOn(converter, "refreshView");

            selectElement.value="4";
            selectElement.dispatchEvent(new Event('change'));
            expect(selector.selectedValue).toEqual(3);
            expect(converter.refreshView).toHaveBeenCalledTimes(1);

            selectElement.value="0"; // 0 = annulation de ce filtre, puisqu'aucune valeur choisie
            selectElement.dispatchEvent(new Event('change'));
            expect(selector.selectedValue).toBeUndefined();
            expect(converter.refreshView).toHaveBeenCalledTimes(2);
        });
        
        it("Doit générer une erreur si une donnée est testée sur un sélecteur non affiché dans la page.", () =>
        {
            selector=new Selector(converter, 3, { id:"selector1" });
            expect(() => { selector.dataIsOk({ "nom"	: "oui" }); }).toThrowError(errors.filterCheckIsOkFail);
        });

        it("Doit toujours retourner true si aucune des valeurs du filtre n'est sélectionnée.",  () =>
        {
            // Le filtre est sur 0 par défaut
            expect(selector.dataIsOk({ "nom"	: "oui" })).toBeTrue();
            // Même comportement après un retour :
            selectElement.value="2";
            selectElement.dispatchEvent(new Event('change'));
            selectElement.value="0";
            selectElement.dispatchEvent(new Event('change'));
            expect(selector.dataIsOk({ "nom"	: "oui" })).toBeTrue();
        });

        it("Doit générer une erreur si la valeur sélectionnée n'est pas trouvé dans la liste des valeurs connues.", () =>
        {
            selectElement.innerHTML=fixtures.selectorHTMLWithFakeItem;
            selectElement.value="13";
            selectElement.dispatchEvent(new Event('change'));
            expect(() => { selector.dataIsOk({ "nom"	: "oui" }); }).toThrowError(errors.selectorSelectedIndexNotFound);
        });
        
        it("Doit retourner false, si la donnée testée ne possède pas le champ sur lequel les données sont filtrées.",  () =>
        {
            selectElement.value="2";
            selectElement.dispatchEvent(new Event('change'));
            expect(selector.dataIsOk({ "nom"	: "rémi sans famille" })).toBeFalse();
        });
        
        it("Doit retourner false, si une donnée testée ne correspond pas à la valeur sélectionnée pour le filtre.",  async () =>
        {
            selectElement.value="4"; // = Halogène
            selectElement.dispatchEvent(new Event('change'));
            expect(selector.dataIsOk({ "Famille": "Hallo Eugène !" })).toBeFalse();
        });
        
        it("Doit retourner true, si une donnée testée correspond pas à la valeur sélectionnée pour ce filtre.",  () =>
        {
            selectElement.value="4";
            selectElement.dispatchEvent(new Event('change'));
            expect(selector.dataIsOk({ "Famille": "Halogène" })).toBeTrue();
            // Y  compris si entouré d'espaces :
            expect(selector.dataIsOk({ "Famille": " Halogène " })).toBeTrue();
        });
    });
    
    describe("Manipulation des sélecteurs avec séparateur.", () =>
    {
        beforeEach( async () =>
        {
            converter.parser.setRemoteSource({ url:"http://localhost:9876/datas/datas1+tagsfield.csv" });
            await converter.run();
            selector=new Selector(converter, 5, { id:"selector1" }, "|"); // filtre sur le champ "Étiquettes"
            selector.filter2HTML();
            selectElement=document.getElementById("freeDatas2HTML_selector1") as HTMLInputElement;
        });
        
        it("Doit retourner false, si la donnée testée ne possède pas le champ sur lequel les données sont filtrées.",  () =>
        {
            selectElement.value="2";
            selectElement.dispatchEvent(new Event('change'));
            expect(selector.dataIsOk({ "nom"	: "oui" })).toBeFalse();
        });
        
        it("Doit retourner false, si une donnée testée ne correspond pas à la valeur sélectionnée pour le filtre.",  () =>
        {
            selectElement.value="4"; // = Exemple3
            selectElement.dispatchEvent(new Event('change'));
            expect(selector.dataIsOk({ "Étiquettes": "Mauvais exemple" })).toBeFalse();
        });
        
        it("Doit retourner true, si une donnée testée correspond pas à la valeur sélectionnée pour ce filtre.",  () =>
        {
            selectElement.value="4";
            selectElement.dispatchEvent(new Event('change'));
            expect(selector.dataIsOk({ "Étiquettes": "Exemple3" })).toBeTrue();
            // Même pas seule :
            expect(selector.dataIsOk({ "Étiquettes": "Exemple3|Exemple1|Exemple9" })).toBeTrue();
            expect(selector.dataIsOk({ "Étiquettes": "Exemple0|Exemple3|Exemple2" })).toBeTrue();
            expect(selector.dataIsOk({ "Étiquettes": "Exemple0|Exemple4|Exemple3" })).toBeTrue();
            // Y  compris si entourée d'espaces :
            expect(selector.dataIsOk({ "Étiquettes": "Exemple0|Exemple4| Exemple3 " })).toBeTrue();
            expect(selector.dataIsOk({ "Étiquettes": " Exemple3 " })).toBeTrue();
        });
    });
    
});