Comment puis-je générer dynamiquement des cas de test en javascript/node?

Le nez framework de test (pour python) prend en charge de générer dynamiquement des cas de test au moment de l'exécution (ci-après, à partir de la documentation, les résultats dans cinq différents cas de test):

def test_evens():
    for i in range(0, 5):
        yield check_even, i, i*3

def check_even(n, nn):
    assert n % 2 == 0 or nn % 2 == 0

Comment puis-je obtenir ce résultat en utilisant des frameworks javascript tels que moka ou qunit? (Je ne suis pas attaché à un cadre particulier à ce stade.)

Mon cas d'utilisation est l'écriture d'un test de coureur à surveiller plusieurs éléments sur un serveur externe. Je voudrais fournir une liste d'Url de ressource. Chaque test de tentatives d'obtention de la ressource et retourne le succès ou l'échec en fonction de ce qu'il trouve. J'ai un prototype construit en python (à l'aide de nez), mais souhaitez mettre en œuvre dans node.js si je peux. Finalement, ce serait incluse dans la CI de l'installation.

nœud comme dans node.js? Peut-être vous devriez le tag, depuis un peu javascript sera interprété en ce sens javascript dans le navigateur.
re-marqué. merci!

InformationsquelleAutor Benj | 2014-03-17

31

Oui, vous pouvez créer dynamiquement des suites de test avec des cas à l'aide de Moka. J'ai installé moka à l'échelle mondiale npm install -g mocha et j'utilise devrait.
```
var should = require('should');

var foo = 'bar';

['nl', 'fr', 'de'].forEach(function(arrElement) {
  describe(arrElement + ' suite', function() {
    it('This thing should behave like this', function(done) {
      foo.should.be.a.String();
      done();
    });
    it('That thing should behave like that', function(done) {
      foo.should.have.length(3);
      done();
    });
  });
});
```
- bon travail, cela a fonctionné pour moi. Un rapide point que vous n'avez probablement pas besoin d'utiliser aysnc. Vous pouvez probablement utiliser simplement ['n1','fr','fr'].forEach(). Si vous tests sont synchrones, ils seront exécutés dans l'ordre, et pas plus lentement que d'habitude. Si vos tests sont asynchrones, puis ils vont s'exécuter de manière asynchrone, mais la boucle forEach va garder la boucle, bien que cela ne devrait pas beaucoup d'importance de toute façon, async.chaque ou [].forEach doit être la même. À moins que quelque chose m'échappe et il() est bloquant en quelque sorte?
- vous avez raison. J'ai mis à jour le code et supprimé l'utilisation de l'asynchrone.
- NB! Cela ne fonctionne qu'en mode synchrone créé dynamiquement des cas de test. Dans le cas général Moka ne supporte pas que.
- Vous avez raison, ce accepté de répondre ne fonctionne que de manière synchrone, ce qui n'est pas réellement répondre à l'OP question à propos de la génération de requêtes du serveur (qui sont toujours async en nodejs). Cependant, vous pouvez générer dynamiquement des tests de manière asynchrone en utilisant le hack dans ma réponse ci-dessous: stackoverflow.com/a/35793665/871990
- J'ai vu votre réponse, mais c'était un peu plus complexe que ce que j'étais prêt à faire pour mettre une bibliothèque dans mon projet. Je viens de passé à node-tap, qui fonctionne bien hors de la boîte.
InformationsquelleAutor Christiaan Westerbeek
21

Si vous voulez créer dynamiquement It() tests à l'aide de données obtenues de manière asynchrone, vous pouvez (ab)utiliser le before() crochet avec un espace réservé It() test pour s'assurer de moka attend jusqu'à ce que before() est exécuté. Voici l'exemple de ma réponse à une question relative à la, pour plus de commodité:
```
before(function () {
    console.log('Let the abuse begin...');
    return promiseFn().
        then(function (testSuite) {
            describe('here are some dynamic It() tests', function () {
                testSuite.specs.forEach(function (spec) {
                    it(spec.description, function () {
                        var actualResult = runMyTest(spec);
                        assert.equal(actualResult, spec.expectedResult);
                    });
                });
            });
        });
});

it('This is a required placeholder to allow before() to work', function () {
    console.log('Mocha should not require this hack IMHO');
});
```
- J'ai essayé toutes les méthodes pour effectuer cette opération, y compris en essayant d'utiliser les TDD cadre de Moka qui n'a pratiquement PAS de documentation. Cette méthode ci-dessus fonctionne, mais je veux juste ajouter que l'extérieur "décrire" est vraiment juste un espace réservé. L'intérieur bloc d'essai est ce qui compte. Vous aurez besoin de revenir une nouvelle promesse une fois les tests dynamiques sont construits et crochet sur cette promesse avec un nouveau "puis" la méthode qui permettra de créer un "après" bloquer. Donc, il y a deux promesses impliqués.
- Si vous ajoutez un after() bloc alors vous remarquerez qu'il n'est pas d'attente pour les before() à la fin. La boucle de la before() va sûrement créer tous ces describe() blocs, mais il ne sera pas attendre pour eux à la fin. Aucun moyen de le réaliser?
- Le before() appel n'complet avant d'invoquer une déclaré after() appels. Cependant, toutes les promesses invoquée à l'intérieur de son rappel peut ne pas être terminée alors, qui est juste la nature de l'asynchrone en javascript. Il semble que votre question est vraiment un plus générale sur la façon javascript promesses de travail et de coordination, plutôt que de générer moka tests dynamiquement, comme demandé dans cette question. Il serait hors-sujet pour aborder les fonctions javascript ici, mais je vous encourage à créer une nouvelle question si vous ne trouvez pas une réponse satisfaisante de votre recherche.
- Je suis en train de l'utiliser dans cyprès - une idée sur pourquoi il l'habitude de travailler pour charger mes attentes fichier et exécutez le il() teste sur elle de façon dynamique?
- Je n'ai pas utilisé de cyprès.io avant, mais la FAQ dit qu'il est construit sur le haut de moka et exécute du javascript dans le navigateur. Ce hack fonctionne avec des régulière mocha.js dans le navigateur, donc je ne sais pas ce qui est différent au sujet de la façon dont le cyprès est l'enveloppant. C'est peut-être mieux posée comme une question séparée, puisque cette question est à propos à l'aide de moka directement?
InformationsquelleAutor rob3c

Il est intéressant de noter que, en plus de la accepté la réponse ci-dessus, moka est docs incluent maintenant un exemple de la façon d'atteindre cet. J'ai reproduit ci-dessous pour la postérité.

var assert = require('assert');

function add() {
  return Array.prototype.slice.call(arguments).reduce(function(prev, curr) {
    return prev + curr;
  }, 0);
}

describe('add()', function() {
  var tests = [
    {args: [1, 2],       expected: 3},
    {args: [1, 2, 3],    expected: 6},
    {args: [1, 2, 3, 4], expected: 10}
  ];

  tests.forEach(function(test) {
    it('correctly adds ' + test.args.length + ' args', function() {
      var res = add.apply(null, test.args);
      assert.equal(res, test.expected);
    });
  });
});

Ce n'est synchrone de données.

InformationsquelleAutor Tom Spencer

Avec Moka 1.21.4, vous pouvez créer la suite/test à l'exécution de la manière suivante.

require('chai').should()

Mocha = require 'mocha'
Test = Mocha.Test
Suite = Mocha.Suite


mocha = new Mocha
suite = Suite.create mocha.suite, 'I am a dynamic suite'
suite.addTest new Test 'I am a dynamic test', ->
  true.should.equal true

mocha.run () ->
  console.log("done")

Voir https://gist.github.com/cybertk/fff8992e12a7655157ed pour plus de détails

InformationsquelleAutor Quanlong

Yep! Brillant conseils de Quanlong!

Voici mon exemple de la dynamique de génération de test avec Nœud readline module:

const Mocha = require('mocha');
var Test = Mocha.Test;
var Suite = Mocha.Suite;

var mocha = new Mocha();
var suite = Suite.create(mocha.suite, 'My test suite with dynamic test cases');

lineReader
    .on('line', function (line) {
        suite.addTest(new Test(line, function () {
            return true;
        }));
    })
    .on('close', function () {
        mocha.run();
    });

InformationsquelleAutor Michael Yurin

J'aime @rob3c réponse, mais a essayé de le simplifier un peu:

describe("Master test suite", function () {
  before(async function () {
    const rows = await mySQLQuery();

    describe(`Testing ${rows.length} rows`, function () {
      rows.forEach(function (row, index) {
        it(`Test row ${index}`, async function() {
          console.log("your row assertions go here")
        });
      });
    });
  });


  it("stub", async function(){})  //this is important!
});

InformationsquelleAutor Jeff Lowery

Vous devez vous connecter pour publier un commentaire.