Introduction détaillée à l'installation et à l'utilisation du framework de test NodeJs Mocha

Cet article présente en détail comment utiliser Mocha afin que vous puissiez démarrer facilement. Si vous ne connaissez rien aux tests auparavant, cet article peut également être utilisé comme introduction aux tests unitaires en JavaScriptPrend en charge l'intégration de l'IDECe qui suit est un résumé concis dans l'ordre du document officiel

Installation et utilisation préliminaire

Exécutez la commande suivante dans la fenêtre de la console :

Vous pouvez écrire le code suivant :

$ npm install -g mocha
$ mk
dir
 test
$ $EDITOR test/test.js

Retournez à la console :

var assert = require('assert');
describe('Array', function() {
  describe('#indexOf()', function () {
    it('should return -1 when the value is not present', function () {
      assert.equal(-1, [1,2,3].indexOf(5));
      assert.equal(-1, [1,2,3].indexOf(0));
    });
  });
});

Ici mocha recherchera le contenu du dossier de test dans le répertoire de fichiers actuel et l'exécutera automatiquement

$  mocha
  .
  ✔ 1 test complete (1ms)

Bibliothèque de jugement

Il s'agit d'un test de jugement. Si le cas d'utilisation réussit, vous pouvez utiliser le. assert bibliothèque de nodejs par défaut. En même temps, Mocha nous aide à utiliser différentes bibliothèques d'assertions. Il peut désormais prendre en charge les bibliothèques d'assertions suivantes. Il existe certaines différences dans l'utilisation de chaque bibliothèque d'assertions. .

1 style BDD Should.js présenté tout au long de ces documents (mode BDD, ce document utilise cette bibliothèque d'assertions)

2 better-assert) assert() auto-documenté de style c (C -

Bibliothèque d'assertions sous le modèle

)
3 assertions de style expect.js expect() (bibliothèque d'assertions en mode attente) 4 inattendues de la boîte à outils d'assertion extensible BDD 5 chai expect() , assert() et devrait styler les assertions

Code de synchronisation

Le code de synchronisation signifie que le test est une fonction de synchronisation. L'exemple de code lié au tableau ci-dessus est plus facile à comprendre >Code asynchrone

Là. ne sont que des tests de code asynchrones car il existe de nombreuses fonctions asynchrones sur nodejs, comme le code suivant. Le scénario de test n'est pas terminé tant que la fonction done() n'est pas exécutée

Explication détaillée de la description et de celle-ci<.>

L'exemple de code ci-dessus est relativement simple, alors que sont-ils décrits ? De manière générale, nous pouvons voir que décrire doit déclarer un TestSuit (collection de tests), et la collection de tests peut être imbriquée et gérée, tandis que l'instruction it définit un scénario de test spécifique. En prenant l'interface bdd comme exemple, le code source spécifique est le suivant :

describe('User', function() {
  describe('#save()', function() {
    it('should save without error', function(done) {
      var user = 
new
 User('Luna');
      user.saveAsync(function(err) {
        
if
 (err) throw err;
        done(); // 只有执行完此函数后，该测试用例算是完成。
      });
    });
  });
});

Hooks (hook)

En fait, il s'agit d'une fonction très courante lors de l'écriture de tests unitaires, qui est pour exécuter des cas de test. Une certaine

fonction de rappel

(hook) est requise avant ou après la collecte des cas de test. Mocha fournit before(), after(), before

  /**
     * Describe a "suite" with the given `title`
     * and callback `fn` containing nested suites
     * and/or tests.
     */
    context.describe = context.context = function(title, fn) {
      var suite = Suite.create(suites[0], title);
      suite.file = file;
      suites.unshift(suite);
      fn.call(suite);
      suites.shift();
      return suite;
    };
      /**
     * Describe a specification or test-case
     * with the given `title` and callback `fn`
     * acting as a thunk.
     */
    context.it = context.specify = function(title, fn) {
      var suite = suites[0];
      if (suite.pending) {
        fn = null;
      }
      var test = new Test(title, fn);
      test.file = file;
      suite.addTest(test);
      return test;
    };

Each

() et aftetEach(). L'exemple de code est le suivant :

les hooks ont également les autres utilisations suivantes : Décrire les hooks - Vous pouvez ajouter une description à la fonction hook pour mieux voir le problèmeHooks asynchrones : la fonction hook peut être synchrone ou asynchrone. Regardons le cas de test Ce qui suit est un hook asynchrone. . Exemple de code :

describe('hooks', function() {
  before(function() {
    // runs before all tests in this block
    // 在执行所有的测试用例前 函数会被调用一次
  });
  after(function() {
    // runs after all tests in this block
    // 在执行完所有的测试用例后 函数会被调用一次
  });
  beforeEach(function() {
    // runs before each test in this block
     // 在执行每个测试用例前 函数会被调用一次
  });
  afterEach(function() {
    // runs after each test in this block
    // 在执行每个测试用例后 函数会被调用一次
  });
  // test cases
});

Hooks au niveau racine (hooks globaux) - sont exécutés en dehors de la description (en dehors de la collection de scénarios de test). Ceci est généralement exécuté avant ou après tous les scénarios de test.

Tests en attente (Tests en attente)

Il y a certains tests qui ne sont pas encore terminés, un peu similaires à TODO, comme le code suivant :

  beforeEach(function(done) {
    // 异步函数
    db.
clear
(function(err) {
      if (err) return done(err);
      db.save([tobi, loki, jane], done);
    });
  });

Tests exclusifs ( Tests exclusifs)

Les tests exclusifs permettent d'exécuter un seul d'un ensemble de tests ou de cas de test, et les autres sont ignorés. Par exemple, la collection de scénarios de test suivante :

describe('Array', function() {
  describe('#indexOf()', function() {
    // pending test below 暂时不写回调函数
    it('should return -1 when the value is not present');
  });
});

Voici le scénario de test :

Il convient de noter que les Hooks (fonctions de rappel) seront exécutés.

describe('Array', function() {
  describe.only('#indexOf()', function() {
    // ...
  });
     // 测试集合不会被执行
    describe('#ingored()', function() {
    // ...
  });
});

Tests inclusifs (y compris les tests)

Contrairement à la fonction unique, la fonction skip fera en sorte que le système moka ignore la collection ou les cas de test actuels, et tous les cas de test ignorés seront signalé pour En attente.

describe('Array', function() {
  describe('#indexOf()', function() {
    it.only('should return -1 unless present', function() {
      // ...
    });
     // 测试用例不会执行
    it('should return the index when present', function() {
      // ...
    });
  });
});

Ce qui suit est un exemple de code pour une collection de cas de test :

L'exemple suivant concerne un cas de test spécifique :

Tests de génération dynamique (générés dynamiquement cas de test)

describe('Array', function() {
   //该测试用例会被ingore掉 
  describe.skip('#indexOf()', function() {
    // ...
  });
   // 该测试会被执行
   describe('#indexOf()', function() {
    // ...
  });
});

En fait, ceci est également disponible dans de nombreux autres outils de test, tels que NUnit, qui remplace les paramètres du scénario de test par un ensemble pour générer différents cas de test. Voici des exemples spécifiques :

describe('Array', function() {
  describe('#indexOf()', function() {
     // 测试用例会被ingore掉
    it.skip('should return -1 unless present', function() {
      // ...
    });
     // 测试用例会被执行
    it('should return the index when present', function() {
      // ...
    });
  });
});

Interfaces (

Interface

)

Le système d'interface de Mocha permet aux utilisateurs d'écrire leurs collections de cas de test avec différents styles de fonctions ou de styles. ainsi que des cas de test spécifiques, mocha possède des interfaces de style BDD, TDD, Exports, QUnit et Require.

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}
  ];
 // 下面就会生成三个不同的测试用例，相当于写了三个it函数的测试用例。
  tests.forEach(function(test) {
    it('correctly adds ' + test.args.length + ' args', function() {
      var res = add.apply(null, test.args);
      assert.equal(res, test.expected);
    });
  });
});

BDD - Il s'agit du style par défaut de moka, et notre exemple de code dans cet article est dans ce format. Il fournit les fonctionsscribe(), context(), it(), before(), after(), beforeEach() et afterEach(). L'exemple de code est le suivant :

.

describe('Array', function() {
    before(function() {
      // ...
    });
    describe('#indexOf()', function() {
      context('when not present', function() {
        it('should not throw an error', function() {
          (function() {
            [1,2,3].indexOf(4);
          }).should.not.throw();
        });
        it('should return -1', function() {
          [1,2,3].indexOf(4).should.equal(-1);
        });
      });
      context('when present', function() {
        it('should return the index where the element first appears in the array', function() {
          [1,2,3].indexOf(3).should.equal(2);
        });
      });
    });
  });

TDD - 提供了 suite(), test(), suiteSetup(), suiteTeardown(), setup(), 和 teardown()的函数，其实和BDD风格的接口类似（suite相当于describe，test相当于it），示例代码如下：

suite('Array', function() {
  setup(function() {
    // ...
  });
  suite('#indexOf()', function() {
    test('should return -1 when not present', function() { 
      assert.equal(-1, [1,2,3].indexOf(4));
    });
  });
});

Exports - 对象的值都是测试用例集合，函数值都是测试用例。 关键字before, after, beforeEach, and afterEach 需要特别定义。
具体的示例代码如下：

module.exports = {
  before: function() {
    // ...
  },
  'Array': {
    '#indexOf()': {
      'should return -1 when not present': function() {
        [1,2,3].indexOf(4).should.equal(-1);
      }
    }
  }
};

QUnit - 有点像TDD，用suit和test函数，也包含before(), after(), beforeEach()和afterEach()，但是用法稍微有点不一样， 可以参考下面的代码：

function ok(expr, msg) {
  if (!expr) throw new Error(msg);
}
suite('Array');
test('#length', function() {
  var arr = [1,2,3];
  ok(arr.length == 3);
});
test('#indexOf()', function() {
  var arr = [1,2,3];
  ok(arr.indexOf(1) == 0);
  ok(arr.indexOf(2) == 1);
  ok(arr.indexOf(3) == 2);
});
suite('String');
test('#length', function() {
  ok('foo'.length == 3);
});

Require - 该接口允许我们利用require关键字去重新封装定义 describe ，it等关键字，这样可以避免全局变量。
如下列代码：

var testCase = require('mocha').describe;
var pre = require('mocha').before;
var assertions = require('mocha').it;
var assert = require('assert');
testCase('Array', function() {
  pre(function() {
    // ...
  });
  testCase('#indexOf()', function() {
    assertions('should return -1 when not present', function() {
      assert.equal([1,2,3].indexOf(4), -1);
    });
  });
});
上述默认的接口是BDD, 如果想

上述默认的接口是BDD, 如果想使用其他的接口，可以使用下面的命令行：

mocha -ui  接口（TDD|Exports|QUnit...）

Reporters （测试报告/结果样式）

Mocha 支持不同格式的测试结果暂时，其支持 Spec， Dot Matrix，Nyan，TAP…等等，默认的样式为Spec，如果需要其他的样式，可以用下列命令行实现：

mocha --reporter 具体的样式（Dot Matrix|TAP|Nyan...）

Editor Plugins

mocha 能很好的集成到TextMate，Wallaby.js，JetBrains（IntelliJ IDEA, WebStorm） 中，这里就用WebStorm作为例子。 JetBrains提供了NodeJS的plugin让我们很好的使用mocha和nodeJs。 添加mocha 的相关的菜单，

这里就可以直接在WebStorm中运行，调试mocha的测试用例了。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!