# Api de test

Cette api écrite en nodejs permet de réaliser des programmes pour réaliser des vérifications pour les tests de non régression.

Cette api n'a pas été conçue pour faire des tests sur un serveur en production.

# Installation

Dans votre répertoire de développement, installer @anakeen/test-tools.

npm install @anakeen/test-tools

ou

yarn add  @anakeen/test-tools

Il faut installer le module anakeen-platform-test-tools sur le serveur que l'on veut tester. Ce module fourni les routes nécessaires à la vérification des tests.

Attention

Il est déconseillé d'installer ce module sur un serveur en production afin d'éviter que les données de tests perturbent le fonctionnement en production.

Les fichiers de test doivent être écrits en nodejs et ils utilisent la bibliothèque mocha.

# Premier test

Le test consiste à créer un smart element de la structure "DEVBILL". On vérifie que le titre est correct et que le Smart Field "bill_content" a aussi la bonne valeur.

Fichier "test1.js" :

//On charge les dépendances
const { Context, AnakeenAssertion } = require("@anakeen/test-tools");
const chai = require("chai");
const expect = chai.expect;

chai.use(AnakeenAssertion);

let serverContext;

//on crée et vérifie le lien avec le context Anakeen Platform
before(async () => {
  // On indique est les paramètres de connexion au serveur web, le login et le mot de passe
  serverContext = await new Context("http://localhost:10083", "admin", "anakeen");
});

//On décrit le test
describe("Test basique :", function() {
  let myTests;
  let seTest;

  // On initialise un contexte de test
  before(async () => {
    myTests = serverContext.initTest();

    // Create a Smart Element for test
    seTest = await myTests.createSmartElement(
      {
        smartStructure: "DEVBILL"
      },
      {
        bill_title: "Hello world",
        bill_content: "This is my message"
      }
    );
  });

  // On nettoie après le test
  // les données créées par la fonction "createSmartElement" sont supprimées
  after(async () => {
    await myTests.clean();
  });

  describe("test the title", () => {
    it("testTitle", async () => {
      await expect(seTest).has.title("Hello world");
    });
  });
  describe("test a field value", () => {
    it("testAFieldValue", async () => {
      await expect(seTest).has.value("bill_content", "This is my message");
    });
  });
});

Lancement du test :

$ npx mocha --timeout=5000 test/test1.js


  Test basique :
    test the title
      ✓ testTitle
    test a field value
      ✓ testAFieldValue (184ms)


  2 passing (959ms)

# Liste des fonctions sur le contexte de test

Toutes ces fonctions retournent une promesse. Le contexte de test est fourni par la fonction initTest().

Fonctions Description
getSmartElement(name : string) : SmartElement Retourne un objet smart Element depuis le serveur
createSmartElement(name : string, values : object) : SmartElement Crée un Smart Element sur le serveur
getAccount(login : string) : Account Retourne un compte utilisateur depuis le serveur
createAccount({login, type="user", roles=[]}) : Account Crée un compte utilisateur sur le serveur
clean() Supprime du serveur les données créées par createSmartElement et createAccount

# Liste des vérifications (assertion) liées à un SmartElement

Assertion Description
expect(se : SmartElement ).has.title(expectedTitle: string) Vérifie si le titre du se sur le serveur correspond
expect(se : SmartElement ).has.profile(profilName:string) Vérifie si le SmartElement est attaché au profil cité
expect(se : SmartElement ).has.workflow(workflowName: string) Vérifie si le SmartElement est attaché au workflow cité
expect(se : SmartElement ).is.alive() Vérifie si le SmartElement est vivant
expect(se : SmartElement ).is.locked() Vérifie si le SmartElement est verrouillé
expect(se : SmartElement ).has.state(stateName: string) Vérifie si le SmartElement est dans l'étape indiquée
expect(se : SmartElement ).has.value(fieldName: string, expectedValue: string) Vérifie si la valeur de champ correspond. La valeur est la valeur brute (tableau de valeur pour les multiples)
expect(se : SmartElement ).has.values({fieldName: expectedvalue, ...}) Vérifie si les valeurs des champ correspond. La valeur est la valeur brute
expect(se : SmartElement ).canUpdateValues({fieldName: expectedvalue, ...}) Vérifie si la mise à jour des valeur déclenche des erreurs ou non
expect(se : SmartElement ).canExecuteTransition(transitionName:string, askValues: object) Vérifie si la transition peut être passée
expect(se : SmartElement ).has.viewControl(cvName : string) Vérifie si le SmartElement est attaché au contrôle de vues cité
expect(se : SmartElement ).has.viewAccess(viewName: string) Vérifie si l'utilisateur a accès à la vue indiqué (nécessite que le SmartElement soit attaché à un contrôle de vue)
expect(se : SmartElement ).has.fieldAccess(fallName: string) Vérifie si le SmartElement est attaché au field access list cité
expect(se : SmartElement ).has.smartElementRight(acl: right) Vérifie si l'utilisateur à le droit indiqué sur le SmartElement
expect(se : SmartElement ).has.smartFieldRight(fieldName:string, access:[read, write, none]) Vérifie si l'utilisateur à le droit indiqué sur le SmartField du SmartElement
expect(se : SmartElement ).has.transitionRight(transitionName:string) Vérifie si l'utilisateur à le droit de passer la transition citée

# Liste des méthodes d'un objet SmartElement

Méthode Description
executeTransition({transition: string, askValues: object}) Réalise le passage d'une transition
setState(newState: string)
updateValues({fieldName: newValue, ...}) Modifie des valeurs de SmartField
getPropertyValue(propertyName: string) Récupère la valeur d'une propriété
getValue(fieldName: string) : string Récupère la valeur formatée ({value, displayValue}) d'un SmartField
getValues() Récupère les valeurs formatées de tous les SmartField
getPropertiesValues() Récupère toutes les valeurs des propriétés
destroy() Supprime le SmartElement

# Test pour un compte donné

La méthode de chaînage for permet de réaliser un test avec un certain "login". Ceci est utile pour tester les accès à certaines informations.
















































 
 
 




const { Context, AnakeenAssertion } = require("../components/lib/TestTools");
const chai = require("chai");
const expect = chai.expect;

chai.use(AnakeenAssertion);

let currentContext;

//on crée et vérifie le lien avec le context Anakeen Platform
before(async () => {
  currentContext = await new Context("http://localhost:10083", "admin", "anakeen");
});

//On décrit le test
describe("Test basique :", function() {
  let testContext;
  let seTest;
  let userBill;

  // On initialise un contexte de test
  before(async () => {
    testContext = currentContext.initTest();

    userBill = await testContext.createAccount({
      login: "testbill1",
      roles: ["bill_writer", "bill_reader"]
    });
    // Create a Smart Element for test
    seTest = await testContext.createSmartElement(
      {
        smartStructure: "DEVBILL"
      },
      {
        bill_title: "Hello world",
        bill_content: "This is my message"
      }
    );
  });

  // On nettoie après le test
  after(async () => {
    await testContext.clean();
  });

  describe("test the title", () => {
    it("1 : testTitle", async () => {
      // Test with user "testbill1"
      await expect(seTest)
        .for(userBill.login)
        .has.title("Hello world");
    });
  });
});