Une bonne vie commence par le 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 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 framework 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();
Enregistrez comme test.jsplus tard, dans la ligne de commande fibjs test.js, vous voyez la sortie suivante, un cadre de test de base a été écrit.
1
2
3
4 hello, test
√ a empty test
√ 1 tests completed (0ms)
Démarrer le serveur de test
Parce que nous devons tester le serveur http, nous devons d'abord démarrer le serveur. Le scénario de test enverra une requête au serveur, puis testera le résultat de la requête 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. D'après cet exemple, nous pouvons effectuer rapidement une série 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 groupée des cas d'utilisation
Ajoutons bonjour test. 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 Regroupant, en même temps, car les contenus de test de hello et bonjour sont les mêmes, nous avons à nouveau optimisé le code et testé les deux ensembles de services avec le même ensemble 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();
En regroupant les cas d'utilisation, nous pouvons voir 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 écrire cette partie des cas de test.
Testez en un clic
Après l'introduction ci-dessus, nous pouvons rapidement établir des cas de test. Mais pour utiliser ce script de test, vous devez d'abord démarrer le serveur, c'est très simple, nous voulons exécuter test.jspour 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());
Ligne 6 à 10 de ce code, nous avons ajouté un main.jscode de démarrage de paragraphe , et attendons un peu, puis reprenons les tests.
Vérification de la couverture du code
Les bons cas de test doivent considérer que les cas de test doivent couvrir toutes les branches de l'entreprise pour garantir 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 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. A ce moment, 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 pour vérifier, vous pouvez voir la page suivante :
Vous pouvez voir que main.jsla couverture du code a atteint 100 %, ce qui signifie que le test couvre complètement la logique métier. Cliquez main.jsplus loin, vous pouvez voir un rapport plus détaillé.