Leitfaden Entwicklungshandbuch

Das gute Leben beginnt mit dem Test

Ein Programmierer, der keine automatisierten Testfälle schreibt, ist kein guter Testingenieur. Wir ermutigen alle Projekte, von Anfang an vollständige automatisierte Testfälle zu erstellen. Mit der Entwicklung des Projekts wird die anfängliche Investition hunderte Male zurückgegeben.

Lassen Sie uns das Beispiel aus dem vorherigen Abschnitt fortsetzen und sehen, wie Testfälle mit fibjs geschrieben werden.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
const 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 10
var test = require('test'); test.setup(); describe('hello, test', () => { it('a empty test', () => { }); }); test.run();

fibjs test.js nach dem Speichern als test.js die fibjs test.js in der Befehlszeile aus. Die folgende Ausgabe wird fibjs test.js , und ein grundlegendes fibjs test.js wird geschrieben.

1 2 3 4
hello, test √ a empty test √ 1 tests completed (0ms)

Starten Sie den Server zu testen

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 Anforderungsergebnis, um festzustellen, ob der Server die Anforderungen erfüllt:

1 2 3 4 5 6 7 8 9 10 11 12 13 14
var 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 bestimmen wir, ob die Serverlogik normal ist, indem wir überprüfen, ob das Ergebnis von http.get unseren Erwartungen entspricht. Anhand dieses Beispiels können wir schnell eine Reihe von Tests durchführen. Gleichzeitig haben wir auch den Code optimiert:

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
var 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();

Use-Case-Gruppierung

Fügen wir einen Test für Bonjour hinzu. Obwohl Bonjour und Hallo dieselben Services sind, müssen wir auch die Richtigkeit des Service überprüfen, da sich der Pfad geändert hat. Dieses Mal haben wir einen Test durchgeführt, um die Anwendungsfälle besser verwalten zu können Da der Testinhalt von Hallo und Bonjour gleich ist, haben wir gleichzeitig den Code erneut optimiert und die beiden Dienste mit demselben Code getestet:

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
var 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 klarer anzeigen und eine Gruppe von Anwendungsfällen einfach einzeln überspringen und testen, um die Entwicklung und die Testgeschwindigkeit zu beschleunigen. Hier 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 des Testfalls meiner Meinung nach schnell schreiben.

Ein-Klick-Test

Nach der Einführung können wir schnell Testfälle erstellen. Um dieses test.js können, muss jedoch zuerst der Server gestartet werden, was sehr unpraktisch ist. Wir hoffen, dass das Ausführen von test.js den Test direkt abschließen kann. Wir können dies mit dem folgenden Code tun:

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 43
var 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 Code zum Starten von main.js und ein wenig gewartet, bevor wir mit dem Testen begonnen haben.

Überprüfung der Codeabdeckung

Bei guten Testfällen muss berücksichtigt werden, dass Testfälle jeden Zweig des Unternehmens abdecken müssen, um festzustellen, ob das Unternehmen ordnungsgemäß ausgeführt wird. Zu diesem Zeitpunkt können Sie mithilfe von Überprüfungen der Codeabdeckung feststellen, ob der Test abgeschlossen ist.

Der Vorgang ist einfach. Fügen Sie beim Testen einfach den Parameter --cov hinzu:

1
fibjs --cov test

Nach Abschluss des Tests wird eine Protokolldatei von fibjs-xxxx.lcov im aktuellen Verzeichnis generiert. Zu diesem Zeitpunkt muss das Protokoll analysiert und ein Bericht erstellt werden:

1
fibjs --cov-process fibjs-xxxx.lcov out

Im out-Verzeichnis kann eine Reihe von Analyseberichten erstellt werden. Geben Sie das Verzeichnis ein, um die folgenden Seiten anzuzeigen: cov Sie können sehen, dass die Codeabdeckung von main.js 100% erreicht hat, was bedeutet, dass der Test die Geschäftslogik vollständig abdeckt. Klicken Sie auf main.js , um detailliertere Berichte main.js .

👉 [ Finde den Performance-Killer heraus ]