Une bonne vie commence par des tests
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 voyons comment utiliser fibjs pour écrire des cas de test.
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 cadre de test vide
Commençons par un cadre de test de base:
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 l'avoir enregistré en tant que test.js , exécutez fibjs test.js sur la ligne de commande, vous verrez la sortie suivante et un cadre de test de base est écrit.
1
2
3
4 hello, test
√ a empty test
√ 1 tests completed (0ms)
Démarrer le serveur de test
Comme 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 jugeons si la logique du serveur est normale en vérifiant si le résultat de http.get est le résultat attendu. Selon cet exemple, nous pouvons effectuer rapidement un ensemble de tests, nous avons également optimisé le 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
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 de groupe des cas d'utilisation
Ajoutons le test bonjour. Bien que bonjour et hello soient le même ensemble de services, car le chemin a changé, nous devons également vérifier l'exactitude du service. Cette fois, afin de mieux gérer les cas d'utilisation, nous avons effectué les cas de test Regroupement, en même temps, car le contenu de test de bonjour et bonjour est le même, nous avons à nouveau optimisé le code et testé les deux ensembles de services avec le même jeu de codes:
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();
Grâce au regroupement des cas d'utilisation, nous pouvons afficher les résultats des tests plus clairement, et il est également facile d'ignorer et de tester un groupe de cas d'utilisation individuellement pour accélérer le développement et les tests. 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 rédiger cette partie des cas de test.
Test en un clic
Après l'introduction ci-dessus, nous pouvons rapidement établir des cas de test. Mais pour utiliser ce script de test, le serveur doit d'abord être démarré, ce qui est très test.js espérons que l'exécution de test.js pourra directement terminer le test. 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é une section de code pour démarrer main.js , et main.js attendu un moment avant de démarrer le test.
Vérification de la couverture du code
Les bons scénarios de test doivent tenir compte du fait que les scénarios de test doivent couvrir toutes les branches de l'entreprise pour garantir que l'entreprise est correctement exécutée. À ce stade, les contrôles de couverture de code peuvent être utilisés pour déterminer si le test est terminé.
Ce processus est très simple, ajoutez simplement le paramètre --cov lors du test:
1fibjs --cov test
Une fois le test terminé, un fichier journal de fibjs-xxxx.lcov sera généré dans le répertoire courant. À ce stade, il est nécessaire d'analyser le journal et de générer un rapport:
1fibjs --cov-process fibjs-xxxx.lcov out
Ensuite, vous pouvez générer un ensemble de rapports d'analyse dans le répertoire out. Entrez dans le catalogue à visualiser, vous pouvez voir la page suivante: 
Comme vous pouvez le voir, la couverture de code de main.js atteint 100%, indiquant que le test couvre complètement la logique métier. Cliquez main.js sur main.js pour afficher un rapport plus détaillé.