FreeDatas2HTML/tests/parserForJSONSpec.ts

import { RemoteSource } from "../src/freeDatas2HTMLInterfaces";
import { ParserForJSON as Parser } from "../src/freeDatas2HTMLParserForJSON";
const errors=require("../src/errors.js");

describe("Tests du parseur de JSON", () =>
{
    let parser: Parser;
        
    beforeEach( () =>
    {
        parser=new Parser();
    });

    it("Doit avoir créé une instance du Parser",  () =>
    {
        expect(parser).toBeInstanceOf(Parser);
    });

    it("Doit générer une erreur si la chaîne de données à parser est vide.", () =>
    {
        expect(() => { return parser.datas2Parse= "" }).toThrowError(errors.parserNeedDatas);
        expect(() => { return parser.datas2Parse= "  " }).toThrowError(errors.parserNeedDatas);
    });

    it("Doit accepter toute chaîne de caractères non vide pour les données à parser.", () =>
    {
        parser. datas2Parse="datas";
        expect(parser.datas2Parse).toEqual("datas");
    });

    it("Doit générer une erreur si le parseur est lancé sans source de données fournie.", async () =>
    {
        await expectAsync(parser.parse()).toBeRejectedWith(new Error(errors.parserNeedSource));
    });

    it("Si le parseur a été appelé avec des données correctes, des résultats doivent être enregistrés.", async () =>
    {
        parser.datas2Parse= `[{ "nom": "dugenoux"},{ "nom": "dupont"}]`;
        await parser.parse();
        expect(parser.parseResults).not.toBeUndefined();
    });

    describe("Accès à des données distantes.", () =>
    {
        it("Doit générer une erreur si l'url fournie pour importer les données est une chaîne vide.", () =>
        {
            expect(() => { return parser.datasRemoteSource= { url:"" } }).toThrowError(errors.parserNeedUrl);
            expect(() => { return parser.datasRemoteSource= { url:"  " } }).toThrowError(errors.parserNeedUrl);
        });
        
        it("Doit accepter des paramètres valides pour la source de données distante.", () =>
        {
            let myRemoteSource: RemoteSource={ url:"zz" };
            parser.datasRemoteSource=myRemoteSource;
            expect(parser.datasRemoteSource).toEqual(myRemoteSource);
            myRemoteSource={ url:"zz", headers: [ { key:"test", value: "coucou"}, { key:"test2", value:"coucou2"}],  withCredentials:true };
            parser.datasRemoteSource=myRemoteSource;
            expect(parser.datasRemoteSource).toEqual(myRemoteSource);
        });
    
        it("Si des options sont fournies pour appeler une ressource distante, elles doivent être prises en compte.", async () =>
        {
            spyOn(window,"fetch").and.callThrough();
            parser.datasRemoteSource={ url: "http://localhost:9876/datas/posts.json", withCredentials:true, headers: [{ key:"Authorization", value:"Token YWxhZGRpbjpvcGVuc2VzYW1l" }]};
            await parser.parse();
            
            const headers=new Headers();      
            headers.append("Authorization", "Token YWxhZGRpbjpvcGVuc2VzYW1l");
            const credentials : RequestCredentials|undefined="include" ;
            const settings={
                    method: "GET",
                    headers: headers,
                    credentials: credentials,
                };
            expect(fetch).toHaveBeenCalledWith("http://localhost:9876/datas/posts.json", settings);
        });

        it("Doit générer une erreur, si l'accès aux données distantes est défaillant.", async () =>
        {
            parser.datasRemoteSource={ url:"http://localhost:9876/datas/posts.jso" }; // une seule lettre vous manque...
            await expectAsync(parser.parse()).toBeRejectedWith(new Error(errors.parserRemoteFail));
        });

        it("Si le parseur a été appelé avec une url fournissant des données correctes, des résultats doivent être enregistrés.", async () =>
        {
            parser.datasRemoteSource={ url:"http://localhost:9876/datas/posts.json" };
            await parser.parse();
            expect(parser.parseResults).not.toBeUndefined();
        });
    });

    describe("Noms des champs et données fournies dans deux tableaux distincts.", () =>
    {
        it("Les valeurs fournies pour les champs doivent être des chaînes de caractères.", () =>
        {
            const fields=["nom",24,"prénom", true,{ field:"champ"},"âge",["je suis un nom de champ"]];
            expect(Parser.trimAllFields(fields)).toEqual(["nom","prénom", "âge"]);
        });

        it("Les espaces entourant les noms de champs doivent être supprimés.", () =>
        {
            const fields=["  nom","prénom  ", " âge "];
            expect(Parser.trimAllFields(fields)).toEqual(["nom","prénom", "âge"]);
        });
        
        it("Si des champs en trop sont trouvés dans une ligne de données, ils doivent être ignorés. Idem pour les champs absents.", async () =>
        {
            parser.datas2Parse=`{ "fields": ["nom","prénom", "âge"], "datas": [["dugenoux","henri",25,"je me champ en trop"],["michu","mariette"]] }`;
            await parser.parse();
            expect(parser.parseResults.fields).toEqual(["nom","prénom", "âge"]);
            expect(parser.parseResults.datas).toEqual([{nom:"dugenoux","prénom":"henri", "âge":"25"}, {nom:"michu","prénom":"mariette"}]);
        });

        it("Si certaines des données fournies ont un type non accepté, elles doivent être ignorées et les erreurs doivent être reportées.", async () =>
        {
            parser.datas2Parse=`{ "fields": ["nom","prénom", "âge"], "datas": [["dugenoux",{ "prenom":"henri"},25],["michu","mariette",null]] }`;
            await parser.parse();
            expect(parser.parseResults.fields).toEqual(["nom","prénom", "âge"]);
            expect(parser.parseResults.datas).toEqual([{nom:"dugenoux", "âge":"25"}, {nom:"michu","prénom":"mariette"}]);
            expect(parser.parseResults.errors[0]).toEqual({row:0,message:errors.parserTypeError+"object"});
            expect(parser.parseResults.errors[1]).toEqual({row:1,message:errors.parserTypeError+"object"});
        });
        
        it("Un enregistrement n'ayant aucune donnée valide sera ignoré.", async () =>
        {
            parser.datas2Parse=`{ "fields": ["nom","prénom", "âge"], "datas": [["dugenoux","henri",25],[null,{ "prenom":"mariette"},[58]]] }`;
            await parser.parse();
            expect(parser.parseResults.fields).toEqual(["nom","prénom", "âge"]);
            expect(parser.parseResults.datas).toEqual([{nom:"dugenoux","prénom":"henri", "âge":"25"}]);
        });

         it("Si toutes les données fournies sont ok, on doit les retrouver en résultat.", async () =>
        {
            parser.datas2Parse=`{ "fields": ["nom","prénom", "âge"], "datas": [["dugenoux","henri",25],["michu","mariette",58]] }`;
            await parser.parse();
            expect(parser.parseResults.fields).toEqual(["nom","prénom", "âge"]);
            expect(parser.parseResults.datas).toEqual([{nom:"dugenoux","prénom":"henri", "âge":"25"}, {nom:"michu","prénom":"mariette", "âge":"58"}]);
        }); 
   });
   
    describe("Données fournies sous forme de tableau d'objets.", () =>
    {                
        it("Les espaces entourant les noms de champs doivent être supprimés.", async () =>
        {
            parser.datas2Parse=`[{"nom  ":"dugenoux","  prénom":"henri"," âge ":25},{"nom":"michu","prénom":"mariette","âge":58}]`;
            await parser.parse();
            expect(parser.parseResults.fields).toEqual(["nom","prénom", "âge"]);
        });

        it("Si certaines des données fournies ont un type non accepté, elles doivent être ignorées ainsi que leur attribut. Et les erreurs doivent être reportées.", async () =>
        {
            parser.datas2Parse=`[{"nom":"dugenoux","prénom":{"value":"henri"},"âge":25},{"âge":"58","nom":"michu","prénom":"mariette","pseudo":["madame Michu"]}]`;
            await parser.parse();
            expect(parser.parseResults.fields).toEqual(["nom", "âge", "prénom"]);
            expect(parser.parseResults.datas).toEqual([{nom:"dugenoux", "âge":"25"}, {"âge":"58", nom:"michu", "prénom":"mariette"}]);
            expect(parser.parseResults.errors[0]).toEqual({row:0,message:errors.parserTypeError+"object"});
            expect(parser.parseResults.errors[1]).toEqual({row:1,message:errors.parserTypeError+"object"});
        });
        
        it("Un enregistrement n'ayant aucune donnée valide doit être ignoré.", async () =>
        {
            parser.datas2Parse=`[{"nom":["dugenoux"],"prénom":{"value":"henri"},"âge":null},{"nom":"michu","prénom":"mariette","âge":58}]`;
            await parser.parse();
            expect(parser.parseResults.fields).toEqual(["nom", "prénom", "âge"]);
            expect(parser.parseResults.datas).toEqual([{ nom:"michu","prénom":"mariette","âge":"58"}]);
        });

        it("Si toutes les données fournies sont ok, on doit les retrouver en résultat.", async () =>
        {
            parser.datas2Parse=`[{"nom":"dugenoux","prénom":"henri","âge":25},{"nom":"michu","prénom":"mariette","âge":58}]`;
            await parser.parse();
            expect(parser.parseResults.fields).toEqual(["nom","prénom", "âge"]);
            expect(parser.parseResults.datas).toEqual([{nom:"dugenoux","prénom":"henri", "âge":"25"}, {nom:"michu","prénom":"mariette", "âge":"58"}]);
            // Tous les objets n'ont pas forcément les mêmes attributs, ni dans le même ordre
            parser.datas2Parse=`[{"nom":"dugenoux","prénom":"henri","âge":"25"},{"âge":"58","nom":"michu","pseudo":"madame Michu"}]`;
            await parser.parse();
            expect(parser.parseResults.fields).toEqual(["nom","prénom", "âge", "pseudo"]);
            expect(parser.parseResults.datas).toEqual([{nom:"dugenoux","prénom":"henri", "âge":"25"}, {"âge":"58", nom:"michu", pseudo:"madame Michu" }]);
        });
   });
   
  it("Doit générer une erreur si les champs n'ont pas été trouvés dans les données.", async () =>
    {
        parser.datas2Parse=`{ "field": ["  nom","prénom  ", " âge "], "datas": [["dugenoux","henri","25"]] }`; // manque un "s" à fields :)
        await expectAsync(parser.parse()).toBeRejectedWith(new Error(errors.parserFail));
        parser.datas2Parse=`[{" ":"dugenoux","  ":"henri"},{" ":"michu","  ":"   "}]`;
        await expectAsync(parser.parse()).toBeRejectedWith(new Error(errors.parserFail));
    });
   
});