FreeDatas2HTML/tests/parserForJSONSpec.ts

174 lines
9.4 KiB
TypeScript

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("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.setRemoteSource({ 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.setRemoteSource({ 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));
});
});