294 lines
14 KiB
TypeScript
294 lines
14 KiB
TypeScript
import { FreeDatas2HTML, Selector } from "../src/freeDatas2HTML";
|
|
const errors=require("../src/errors.js");
|
|
const fixtures=require("./fixtures.js");
|
|
|
|
xdescribe("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 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);
|
|
});
|
|
});
|
|
}); |