315 lines
15 KiB
TypeScript
315 lines
15 KiB
TypeScript
import { FreeDatas2HTML, Render} from "../src/FreeDatas2HTML";
|
|
const errors=require("../src/errors.js");
|
|
const fixtures=require("./fixtures.js");
|
|
|
|
/// EN CHANTIER !!!
|
|
/// Tests à revoir après avoir fait le tour des autres classes
|
|
/*
|
|
describe("Test du script central de FreeDatas2HTML", () =>
|
|
{
|
|
let converter: FreeDatas2HTML;
|
|
|
|
beforeEach( () =>
|
|
{
|
|
converter=new FreeDatas2HTML("CSV");
|
|
converter.parser.setRemoteSource({ url:"http://localhost:9876/datas/datas1.csv" });
|
|
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.", () =>
|
|
{
|
|
expect(() => { return FreeDatas2HTML.checkInDOMById({ id:"dontExist" }); }).toThrowError(errors.converterElementNotFound+"dontExist");
|
|
});
|
|
|
|
it("S'il y a bien un élément dans la page pour l'id fourni, doit retourner l'élement DOM complété.", () =>
|
|
{
|
|
const eltInDOM=document.getElementById("datas");
|
|
const checkElt=FreeDatas2HTML.checkInDOMById({ id:"datas" });
|
|
expect(checkElt).toEqual({ id:"datas", eltDOM: eltInDOM });
|
|
});
|
|
|
|
it("Doit retourner false si un numéro de champ n'est pas trouvé dans les données.", async () =>
|
|
{
|
|
let check=converter.checkFieldExist(2); // aucune donnée chargée, donc le champ ne peut être trouvé
|
|
expect(check).toBeFalse();
|
|
await converter.run();
|
|
check=converter.checkFieldExist(-2);
|
|
expect(check).toBeFalse();
|
|
check=converter.checkFieldExist(1.1);
|
|
expect(check).toBeFalse();
|
|
check=converter.checkFieldExist(10);
|
|
expect(check).toBeFalse();
|
|
});
|
|
|
|
it("Doit retourner true si un numéro de champ est bien trouvé dans les données.", async () =>
|
|
{
|
|
await converter.run();
|
|
let check=converter.checkFieldExist(0);
|
|
expect(check).toBeTrue();
|
|
check=converter.checkFieldExist(2);
|
|
expect(check).toBeTrue();
|
|
});
|
|
|
|
it("Doit générer une erreur si une fonction est associée à un champ n'existant pas dans les données.", async () =>
|
|
{
|
|
const simpleSort = (a: any, b: any) =>
|
|
{
|
|
if(a < b)
|
|
return 1;
|
|
else if(a > b)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
};
|
|
expect(() => { return converter.datasSortingFunctions=[{ datasFieldNb:0, sort:simpleSort }]; }).toThrowError(errors.converterFieldNotFound); // données non chargées
|
|
converter=new FreeDatas2HTML("CSV");
|
|
converter.parser.setRemoteSource({ url:"http://localhost:9876/datas/datas1.csv" });
|
|
await converter.run();
|
|
expect(() => { return converter.datasSortingFunctions=[{ datasFieldNb:10, sort:simpleSort }]; }).toThrowError(errors.converterFieldNotFound);
|
|
});
|
|
|
|
it("Doit accepter la fonction associée à un champ, de manière à ce qu'elle soit utilisable pour comparer deux valeurs.", async () =>
|
|
{
|
|
const simpleSort = (a: any, b: any) =>
|
|
{
|
|
if(a < b)
|
|
return 1;
|
|
else if(a > b)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
};
|
|
await converter.run();
|
|
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]);
|
|
});
|
|
});
|
|
|
|
describe("Affichage des données reçues.", () =>
|
|
{
|
|
it("Doit générer une erreur si des données n'ont pas été importées.", async () =>
|
|
{
|
|
// Parseur non lancé :
|
|
expect(() => { return converter.refreshView(); }).toThrowError(errors.converterRefreshFail);
|
|
// Lancé, mais sur un fichier vide : à revoir, car c'est le parseur qui génère d'abord une erreur
|
|
//converter=new FreeDatas2HTML("CSV","", { url:"http://localhost:9876/datas/nodatas.csv"});
|
|
//await converter.run();
|
|
//expect(() => { return converter.refreshView(); }).toThrowError(errors.converterRefreshFail);
|
|
});
|
|
|
|
it("Doit générer une erreur si l'élément du DOM où afficher les données est inconnu.", async () =>
|
|
{
|
|
await converter.run();
|
|
expect(() => { return converter.refreshView(); }).toThrowError(errors.converterRefreshFail);
|
|
});
|
|
|
|
it("Ne doit pas générer d'erreur si les informations nécessaires sont ok.", async () =>
|
|
{
|
|
converter.datasViewElt={ id:"datas" };
|
|
await converter.run();
|
|
expect(() => { return converter.refreshView(); }).not.toThrowError();
|
|
});
|
|
|
|
it("Doit générer une erreur, si la moindre erreur est rencontrée durant la parsage et que cela n'est pas accepté.", async () =>
|
|
{
|
|
converter=new FreeDatas2HTML("CSV");
|
|
converter.parser.setRemoteSource({ url:"http://localhost:9876/datas/datas-errors1.csv" });
|
|
converter.stopIfParseErrors=true;
|
|
await expectAsync(converter.run()).toBeRejectedWith(new Error(errors.parserMeetErrors));
|
|
});
|
|
|
|
it("Si cela n'est pas demandé, le script ne sera pas bloqué, même si des erreurs sont rencontrées durant le parsage.", async () =>
|
|
{
|
|
converter.datasViewElt={ id:"datas" };
|
|
converter=new FreeDatas2HTML("CSV");
|
|
converter.parser.setRemoteSource({ url:"http://localhost:9876/datas/datas-errors1.csv" });
|
|
await expectAsync(converter.run()).toBeResolved();
|
|
});
|
|
|
|
/// Plutôt pour tester Render
|
|
it("Doit afficher un tableau correspondant aux données du fichier csv", async () =>
|
|
{
|
|
converter.datasViewElt={ id:"datas" };
|
|
await converter.run();
|
|
const render=new Render();
|
|
render.datas=converter.datas;
|
|
const htmlForDatas=render.rend2HTML();
|
|
// On ne peut comparer directement au contenu du DOM,
|
|
// car le navigateur change certains caractères (exemple : ">" devient ">")
|
|
expect(converter.datasHTML).toEqual(htmlForDatas);
|
|
// Mais le code commence tout de même par <table> :
|
|
const txtDatasViewsElt=document.getElementById("datas").innerHTML;
|
|
expect(txtDatasViewsElt.indexOf("<table>")).toEqual(0);
|
|
// Et on doit retrouver le bon nombre de lignes :
|
|
const getTR=document.getElementsByTagName("tr");
|
|
expect(getTR.length).toEqual(119);
|
|
});
|
|
|
|
it("Si demandé, doit afficher le nombre de lignes de données du fichier.", async () =>
|
|
{
|
|
converter.datasViewElt={ id:"datas" };
|
|
converter.datasCounter={ id:"counter" };
|
|
await converter.run();
|
|
let txtDatasViewsElt=document.getElementById("counter").innerHTML;
|
|
expect(txtDatasViewsElt).toEqual("118");
|
|
});
|
|
});
|
|
|
|
/* describe("Action des champs de classement en corrélation avec le convertisseur.", () =>
|
|
{
|
|
|
|
it("Le 1er clic sur l'entête d'une des colonnes doit classer les données dans le sens ascendant, puis descendant et ainsi de suite.", async () =>
|
|
{
|
|
let sortingField=new SortingField(converter, 2);
|
|
sortingField.field2HTML();
|
|
converter.datasSortingFields=[sortingField];
|
|
let getTHLink=document.querySelector("th a") as HTMLElement;
|
|
getTHLink.click();// tri ascendant
|
|
let getTR=document.querySelectorAll("tr");
|
|
let txtDatasViewsElt=getTR[1].innerHTML;
|
|
expect(txtDatasViewsElt).toEqual("<td>89</td><td>Actinium</td><td>Ac</td><td>Actinide</td><td>≤ 1</td>");
|
|
getTHLink.click();// tri descendant
|
|
getTR=document.querySelectorAll("tr");
|
|
txtDatasViewsElt=getTR[1].innerHTML;
|
|
expect(txtDatasViewsElt).toEqual("<td>40</td><td>Zirconium</td><td>Zr</td><td>Métal de transition</td><td>> 100000</td>");
|
|
getTHLink.click();// de nouveau ascendant
|
|
getTR=document.querySelectorAll("tr");
|
|
txtDatasViewsElt=getTR[1].innerHTML;
|
|
expect(txtDatasViewsElt).toEqual("<td>89</td><td>Actinium</td><td>Ac</td><td>Actinide</td><td>≤ 1</td>");
|
|
});
|
|
|
|
it("Prise en compte d'une fonction spécifique associée au champ de classement.", async () =>
|
|
{
|
|
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 }];
|
|
let sortingField=new SortingField(converter, 4);
|
|
sortingField.field2HTML();
|
|
converter.datasSortingFields=[sortingField];
|
|
let getTHLink=document.querySelector("th a") as HTMLElement;
|
|
getTHLink.click();// tri ascendant
|
|
let getTR=document.querySelectorAll("tr");
|
|
let txtDatasViewsElt=getTR[1].innerHTML;
|
|
expect(txtDatasViewsElt).toEqual("<td>95</td><td>Américium</td><td>Am</td><td>Actinide</td><td>Inexistant</td>");
|
|
getTHLink.click();// tri descendant
|
|
getTR=document.querySelectorAll("tr");
|
|
txtDatasViewsElt=getTR[1].innerHTML;
|
|
expect(txtDatasViewsElt).toEqual("<td>1</td><td>Hydrogène</td><td>H</td><td>Non-métal</td><td>> 100000</td>");
|
|
getTHLink.click();// de nouveau ascendant
|
|
getTR=document.querySelectorAll("tr");
|
|
txtDatasViewsElt=getTR[1].innerHTML;
|
|
expect(txtDatasViewsElt).toEqual("<td>95</td><td>Américium</td><td>Am</td><td>Actinide</td><td>Inexistant</td>");
|
|
});
|
|
|
|
|
|
|
|
}); */
|
|
|
|
/*
|
|
describe("Création et action des sélecteurs liés à la pagination des données.", () =>
|
|
{
|
|
beforeEach( () =>
|
|
{
|
|
pagination.options={ displayElement: { id:"paginationOptions" }, values: [10,20,50,500] , name: "Choix de pagination :" };
|
|
pagination.selectedValue=10;
|
|
pagination.options2HTML();
|
|
converter.pagination=pagination;
|
|
//converter.refreshView();
|
|
});
|
|
|
|
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("La manipulation du sélecteur de pagination doit appeler la fonction actualisant l'affichage.", () =>
|
|
{
|
|
spyOn(converter, "refreshView");
|
|
let selectElement=document.getElementById("freeDatas2HTMLPaginationSelector") as HTMLInputElement;
|
|
selectElement.value="2";
|
|
selectElement.dispatchEvent(new Event('change'));
|
|
expect(converter.refreshView).toHaveBeenCalledTimes(1);
|
|
selectElement.value="0";
|
|
selectElement.dispatchEvent(new Event('change'));
|
|
expect(converter.refreshView).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
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("La manipulation du sélecteur de pages doit appeler la fonction actualisant l'affichage.", () =>
|
|
{
|
|
spyOn(converter, "refreshView");
|
|
let selectElement=document.getElementById("freeDatas2HTMLPagesSelector") as HTMLInputElement;
|
|
selectElement.value="2";
|
|
selectElement.dispatchEvent(new Event('change'));
|
|
expect(converter.refreshView).toHaveBeenCalledTimes(1);
|
|
selectElement.value="0";
|
|
selectElement.dispatchEvent(new Event('change'));
|
|
expect(converter.refreshView).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
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();
|
|
});
|
|
});
|
|
});*/ |