Exécution du même test mocha plusieurs fois avec des données différentes

une approche de base pour exécuter le même test avec des données différentes est de répéter le test dans une boucle fournissant les données:

describe('my tests', function () {
  var runs = [
    {it: 'options1', options: {...}},
    {it: 'options2', options: {...}},
  ];

  before(function () {
    ...
  });

  runs.forEach(function (run) {
    it('does sth with ' + run.it, function () {
      ...
    });
  });
});

before fonctionne, bien, avant tout its:describe. Si vous avez besoin d'utiliser certaines options dans before,ne pas l'inclure dans le forEach boucle parce que mocha va d'abord courir tout befores et its, qui n'est probablement pas voulu. Vous pouvez soit mettre l'ensemble de l' describe dans la boucle:

var runs = [
  {it: 'options1', options: {...}},
  {it: 'options2', options: {...}},
];

runs.forEach(function (run) {
  describe('my tests with ' + run.it, function () {
    before(function () {
      ...
    });

    it('does sth with ' + run.it, function () {
      ...
    });
  });
});

Si vous ne souhaite pas polluer vos tests avec plusieurs describes, vous pouvez utiliser le controversé module sinon pour cette question:

var sinon = require('sinon');

describe('my tests', function () {
  var runs = [
    {it: 'options1', options: {...}},
    {it: 'options2', options: {...}},
  ];

  // use a stub to return the proper configuration in `beforeEach`
  // otherwise `before` is called all times before all `it` calls
  var stub = sinon.stub();
  runs.forEach(function (run, idx) {
    stub.onCall(idx).returns(run);
  });

  beforeEach(function () {
    var run = stub();
    // do something with the particular `run.options`
  });

  runs.forEach(function (run, idx) {
    it('does sth with ' + run.it, function () {
      sinon.assert.callCount(stub, idx + 1);
      ...
    });
  });
});

Sinon se sent sale, mais est efficace. Plusieurs modules d'aide tels que leche sont basés sur le sinon, mais il est permis de penser qu'il n'est pas nécessaire d'introduire davantage de complexité.

Leche ajoute cette fonctionnalité à Mocha. Voir le annonce et docs.

c'est mieux que de simplement faire une boucle au-dessus des tests parce que, si un test échoue, il vous dit quel ensemble de données a été impliqué.

mise à Jour:

Je n'ai pas aimé la configuration de Leche et n'ai pas réussi à la faire fonctionner avec Karma, donc finalement j'ai extrait le fournisseur de données dans un fichier séparé.

Si vous voulez l'utiliser, il suffit saisir la source. La Documentation est disponible dans le Leche readme, et vous pourrez trouver des informations supplémentaires et conseils d'utilisation dans le fichier lui-même.

basé sur la réponse de @Kaizo, voici ce que j'ai trouvé pour mon test (c'est un contrôleur qui reçoit quelques paramètres de la requête) pour émuler le fournisseur de données dans PHPUnit. getParameters method va recevoir la requête D'Express, puis utiliser req.param pour inspecter certains paramètres de la requête, par exemple, GET /jobs/?page=1&per_page=5. Cela montre aussi comment couper L'objet Requête Express.

espérons que cela puisse aussi aider quelqu'un.

// Core modules.
var assert = require('assert');

// Public modules.
var express = require('express');
var sinon = require('sinon');

// Local modules.
var GetJobs = require(__base + '/resources/jobs/controllers/GetJobs');

/**
 * Test suite for the `GetJobs` controller class.
 */
module.exports = {
    'GetJobs.getParameters': {
        'should parse request parameters for various cases': function () {
            // Need to stub the request `param` method; see http://expressjs.com/3x/api.html#req.param
            var stub = sinon.stub(express.request, 'param');
            var seeds = [
                // Expected, page, perPage
                [{limit: 10, skip: 0}],
                [{limit: 5, skip: 10}, 3, 5]
            ];
            var controller = new GetJobs();

            var test = function (expected, page, perPage) {
                stub.withArgs('page').returns(page);
                stub.withArgs('per_page').returns(perPage);

                assert.deepEqual(controller.getParameters(express.request), expected);
            };

            seeds.forEach(function (seed) {
                test.apply({}, seed);
            });
        }
    }
};

le seul inconvénient est Moka ne compte pas les affirmations réelles (comme le fait PHPUnit), il apparaît juste comme un test.

une solution plus simple est décrite ci-dessous en utilisant moka-testdata bibliothèque.

exemple de solution au problème.

import * as assert from assert;
import { givenAsync } from mocha-testdata;

suite('My async test suite', function () {
  given([0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 3]).test('sum to 6', function (a, b, c) {
    assert.strictEqual(a + b + c, 6);
  });
});

si vous avez besoin de tester les appels de fonction async qui est le cas le plus commun dans le noeud.js app, utilisez givenAsync à la place.

import * as assert from assert;
import { givenAsync } from mocha-testdata;

suite('My async test suite', function () {
  givenAsync([1, 2, 3], [3, 2, 1]).test('sum to 6', function (done, a, b, c) {
    doSomethingAsync(function () {
        assert.strictEqual(a + b + c, 6);
        done();
    });
  });
});

j'ai trouvé moka-testcheck pour être l'outil le plus simple pour cela. Il génère des données de toutes sortes. Il permet de réduire le nombre d'entrées qui causent l'échec de votre test.