Une bonne vie commence par un test
Un programmeur qui n'écrit pas de cas de test automatiques n'est pas un bon ingénieur de test. Nous encourageons tous les projets à établir des cas de test automatisés complets dès le début. Avec le développement du projet, l'investissement initial sera récompensé des centaines de fois.
Continuons l'exemple de la section précédente et examinons comment écrire des cas de test à l'aide de fibjs.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21const http = require('http');
const path = require('path');
var hello_server = {
'/:name(fibjs.*)': (req, name) => {
req.response.write('hello, ' + name + '. I love you.');
},
'/:name': (req, name) => {
req.response.write('hello, ' + name);
}
};
var root_server = {
'/hello': hello_server,
'/bonjour': hello_server,
'*': http.fileHandler(path.join(__dirname, 'web'))
};
var svr = new http.Server(8080, root_server);
svr.start();
Un framework de test vide
Commençons par le framework de test le plus basique:
1
2
3
4
5
6
7
8
9
10var test = require('test');
test.setup();
describe('hello, test', () => {
it('a empty test', () => {
});
});
test.run();
Après avoir enregistré en tant que test.js , exécutez fibjs test.js sur la ligne de commande, vous verrez la sortie suivante, un cadre de test de base est écrit.
1
2
3
4 hello, test
√ a empty test
√ 1 tests completed (0ms)
Commencez à tester le serveur
Parce que nous devons tester le serveur http, nous devons d'abord démarrer le serveur. Le scénario de test enverra une demande au serveur, puis testera le résultat de la demande pour déterminer si le serveur répond aux exigences:
1
2
3
4
5
6
7
8
9
10
11
12
13
14var test = require('test');
test.setup();
var http = require('http');
describe('hello, test', () => {
it('hello, fibjs', () => {
var r = http.get('http://127.0.0.1:8080/hello/fibjs');
assert.equal(r.statusCode, 200);
assert.equal(r.data.toString(), 'hello, fibjs. I love you.');
});
});
test.run();
Dans ce code, nous déterminons si la logique du serveur est normale en vérifiant que le résultat de http.get correspond à ce que nous attendons. En suivant cet exemple, nous pouvons effectuer rapidement un ensemble de tests, et nous avons optimisé le code en même temps:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30var test = require('test');
test.setup();
var http = require('http');
function test_get(url, rep) {
var r = http.get('http://127.0.0.1:8080' + url);
assert.equal(r.statusCode, 200);
assert.equal(r.data.toString(), rep);
}
describe('hello, test', () => {
it('hello, fibjs', () => {
test_get('/hello/fibjs', 'hello, fibjs. I love you.');
});
it('hello, fibjs*', () => {
test_get('/hello/fibjs-great', 'hello, fibjs-great. I love you.');
});
it('hello, JavaScript', () => {
test_get('/hello/JavaScript', 'hello, JavaScript');
});
it('hello, v8', () => {
test_get('/hello/v8', 'hello, v8');
});
});
test.run();
Gestion des regroupements de cas d'utilisation
Ensuite, ajoutons bonjour test. Bien que bonjour et hello soient le même ensemble de services, nous devons également vérifier l'exactitude du service car le chemin a changé. Cette fois, afin de mieux gérer les cas d'utilisation, nous avons effectué des cas de test Regroupement, en même temps, car le contenu du test de hello et bonjour est le même, nous avons à nouveau optimisé le code et testé deux ensembles de services avec le même ensemble de code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37var test = require('test');
test.setup();
var http = require('http');
function test_get(url, rep) {
var r = http.get('http://127.0.0.1:8080' + url);
assert.equal(r.statusCode, 200);
assert.equal(r.data.toString(), rep);
}
describe('hello, test', () => {
function test_hello(hello) {
describe(hello + ' test', () => {
it('fibjs', () => {
test_get('/' + hello + '/fibjs', 'hello, fibjs. I love you.');
});
it('fibjs*', () => {
test_get('/' + hello + '/fibjs-great', 'hello, fibjs-great. I love you.');
});
it('JavaScript', () => {
test_get('/' + hello + '/JavaScript', 'hello, JavaScript');
});
it('v8', () => {
test_get('/' + hello + '/v8', 'hello, v8');
});
});
}
test_hello('hello');
test_hello('bonjour');
});
test.run();
En regroupant les cas d'utilisation, nous pouvons afficher les résultats des tests plus clairement, et il est également facile d'ignorer et de tester individuellement un groupe de cas d'utilisation, accélérant ainsi la vitesse de développement et de test. Voici les résultats de cette série de tests:
1
2
3
4
5
6
7
8
9
10
11
12
13 hello, test
hello test
√ fibjs
√ fibjs*
√ JavaScript
√ v8
bonjour test
√ fibjs
√ fibjs*
√ JavaScript
√ v8
√ 8 tests completed (3ms)
Selon la conception de notre serveur, nous avons également un ensemble de services de fichiers statiques. Selon l'exemple ci-dessus, je pense que vous pouvez rapidement écrire cette partie du scénario de test.
Test en un clic
Après l'introduction ci-dessus, nous pouvons rapidement créer des cas de test. Mais pour utiliser ce script de test, le serveur doit être démarré en premier, ce qui est très gênant. Nous espérons exécuter test.js pour terminer le test directement. Nous pouvons utiliser le code suivant pour réaliser:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43var test = require('test');
test.setup();
var http = require('http');
var coroutine = require('coroutine');
coroutine.start(() => {
run('./main.js');
});
coroutine.sleep(100);
function test_get(url, rep) {
var r = http.get('http://127.0.0.1:8080' + url);
assert.equal(r.statusCode, 200);
assert.equal(r.data.toString(), rep);
}
describe('hello, test', () => {
function test_hello(hello) {
describe(hello + ' test', () => {
it('fibjs', () => {
test_get('/' + hello + '/fibjs', 'hello, fibjs. I love you.');
});
it('fibjs*', () => {
test_get('/' + hello + '/fibjs-great', 'hello, fibjs-great. I love you.');
});
it('JavaScript', () => {
test_get('/' + hello + '/JavaScript', 'hello, JavaScript');
});
it('v8', () => {
test_get('/' + hello + '/v8', 'hello, v8');
});
});
}
test_hello('hello');
test_hello('bonjour');
});
process.exit(test.run());
Aux lignes 6 à 10 de ce code, nous avons ajouté un code pour démarrer main.js et main.js attendu un peu avant de commencer le test.
Vérification de la couverture du code
Un bon scénario de test doit tenir compte du fait qu'il doit couvrir toutes les branches de l'entreprise pour s'assurer que l'entreprise est exécutée correctement. À ce stade, la vérification de la couverture du code peut être utilisée pour déterminer si le test est terminé.
Ce processus est très simple, il suffit d'ajouter le paramètre --cov pendant le test:
1fibjs --cov test
Une fois le test terminé, un fichier journal fibjs-xxxx.lcov sera généré dans le répertoire en cours. À ce stade, vous devez analyser le journal et générer un rapport:
1fibjs --cov-process fibjs-xxxx.lcov out
Vous pouvez générer un ensemble de rapports d'analyse dans le répertoire out. Entrez dans le répertoire à afficher, vous pouvez voir la page suivante: 
Comme vous pouvez le voir, la couverture du code de main.js atteint 100%, ce qui indique que le test a complètement couvert la logique métier. Cliquez sur main.js pour afficher un rapport plus détaillé.