Ein gutes Leben beginnt mit dem Test
Ein Programmierer, der keine automatischen Testfälle schreibt, ist kein guter Testingenieur. Wir empfehlen allen Projekten, zu Beginn vollständige automatisierte Testfälle zu erstellen. Mit der Entwicklung des Projekts wird die anfängliche Investition hunderte Male belohnt.
Lassen Sie uns das Beispiel aus dem vorherigen Abschnitt fortsetzen und einen Blick darauf werfen, wie Fibjs zum Schreiben von Testfällen verwendet werden.
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();
Ein leerer Testrahmen
Beginnen wir mit einem grundlegenden Test-Framework:
1
2
3
4
5
6
7
8
9
10var test = require('test');
test.setup();
describe('hello, test', () => {
it('a empty test', () => {
});
});
test.run();
Speichern Sie test.jsspäter, in der Befehlszeile sehen fibjs test.jsSie die folgende Ausgabe, ein grundlegendes Testframework wurde geschrieben.
1
2
3
4 hello, test
√ a empty test
√ 1 tests completed (0ms)
Starten Sie den Testserver
Da wir den http-Server testen müssen, müssen wir zuerst den Server starten. Der Testfall sendet eine Anforderung an den Server und testet dann das Ergebnis der Anforderung, um festzustellen, ob der Server die Anforderungen erfüllt:
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();
In diesem Code beurteilen wir, ob die Serverlogik normal ist, indem wir überprüfen, ob das Ergebnis von http.get das erwartete Ergebnis ist. Nach diesem Beispiel können wir schnell eine Reihe von Tests durchführen und gleichzeitig den Code optimieren:
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();
Gruppenverwaltung von Anwendungsfällen
Fügen wir den Bonjour-Test hinzu. Obwohl Bonjour und Hallo die gleichen Services sind, müssen wir auch die Richtigkeit des Service überprüfen, da sich der Pfad geändert hat. Dieses Mal haben wir die Testfälle durchgeführt, um die Anwendungsfälle besser verwalten zu können Gleichzeitig haben wir den Code erneut optimiert und die beiden Dienste mit demselben Satz von Codes getestet, da der Testinhalt von Hallo und Bonjour identisch ist.
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();
Durch die Gruppierung von Anwendungsfällen können wir die Testergebnisse übersichtlicher anzeigen. Außerdem ist es einfach, eine Gruppe von Anwendungsfällen einzeln zu überspringen und zu testen, um die Entwicklungs- und Testgeschwindigkeit zu beschleunigen. Das Folgende sind die Ergebnisse dieser Testrunde:
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)
Entsprechend unserem Serverdesign verfügen wir auch über eine Reihe statischer Dateidienste. Gemäß dem obigen Beispiel können Sie diesen Teil der Testfälle meiner Meinung nach schnell aufschreiben.
Ein-Klick-Test
Nach der obigen Einführung können wir schnell Testfälle erstellen. Um dieses Testskript verwenden zu können, müssen Sie zuerst den Server starten. Dies ist sehr einfach. Wir möchten ihn ausführen test.js, um den Test direkt abzuschließen. Wir können den folgenden Code verwenden, um dies zu erreichen:
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());
In den Zeilen 6 bis 10 dieses Codes haben wir einen Absatzstartcode hinzugefügt main.js, ein wenig gewartet und dann die Tests neu gestartet.
Überprüfung der Codeabdeckung
Bei guten Testfällen muss berücksichtigt werden, dass die Testfälle alle Unternehmensbereiche abdecken müssen, um sicherzustellen, dass das Unternehmen ordnungsgemäß ausgeführt wird. Zu diesem Zeitpunkt kann mithilfe der Überprüfung der Codeabdeckung festgestellt werden, ob der Test abgeschlossen ist.
Dieser Vorgang ist sehr einfach. Fügen Sie beim Testen einfach den Parameter --cov hinzu:
1fibjs --cov test
Nach Abschluss des Tests wird eine Protokolldatei von fibjs-xxxx.lcov im aktuellen Verzeichnis generiert. Zu diesem Zeitpunkt ist es erforderlich, das Protokoll zu analysieren und einen Bericht zu erstellen:
1fibjs --cov-process fibjs-xxxx.lcov out
Anschließend können Sie eine Reihe von Analyseberichten im Verzeichnis out erstellen. Geben Sie den zu überprüfenden Katalog ein. Sie sehen die folgende Seite:
Sie können sehen, dass main.jsdie Codeabdeckung 100% erreicht hat, was bedeutet, dass der Test die Geschäftslogik vollständig abdeckt. Klicken main.jsSie weiter, um einen detaillierteren Bericht anzuzeigen.