Leitfaden Entwicklungshandbuch

Ein gutes Leben beginnt mit einem Test

Ein Programmierer, der keine automatischen 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 belohnt.

Lassen Sie uns das Beispiel aus dem vorherigen Abschnitt fortsetzen und einen Blick darauf werfen, 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 leeres Testframework

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

Nachdem Sie als test.js , führen Sie fibjs test.js in der Befehlszeile aus. Sie sehen die folgende Ausgabe, 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 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 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();

Gruppierung der Verwaltung von Anwendungsfällen

Fügen wir Bonjour-Tests hinzu. Obwohl Bonjour und Hallo dieselben Services sind, müssen wir aufgrund der Pfadänderung auch die Richtigkeit des Service überprüfen. Dieses Mal haben wir Testfälle durchgeführt, um die Anwendungsfälle besser verwalten zu können Gleichzeitig haben wir den Code erneut optimiert und zwei Sätze von Diensten mit demselben Satz von Code getestet, da der Testinhalt von Hallo und Bonjour gleich 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 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 Gruppieren der Anwendungsfälle 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 des Testfalls meiner Meinung nach schnell schreiben.

Ein-Klick-Test

Nach der obigen Einführung können wir schnell Testfälle erstellen. Um dieses test.js zu können, muss jedoch zuerst der Server gestartet werden, was sehr unpraktisch ist. Wir hoffen, test.js zu können, um den Test direkt test.js . 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 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 hinzugefügt und ein wenig gewartet, bevor wir den Test gestartet main.js .

Überprüfung der Codeabdeckung

Bei guten Testfällen muss berücksichtigt werden, dass die Testfälle jeden Geschäftszweig abdecken müssen, um die korrekte Ausführung des Geschäfts zu bestimmen. Zu diesem Zeitpunkt können Codeabdeckungsprüfungen verwendet werden, um festzustellen, ob der Test abgeschlossen ist.

Dieser Vorgang ist sehr einfach. Fügen Sie während des Tests einfach den Parameter --cov hinzu:

1
fibjs --cov test

Nach Abschluss des Tests wird im aktuellen Verzeichnis eine Protokolldatei von fibjs-xxxx.lcov generiert. Zu diesem Zeitpunkt müssen Sie das Protokoll analysieren und einen Bericht erstellen:

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

Sie können eine Reihe von Analyseberichten im out-Verzeichnis erstellen. Geben Sie das anzuzeigende Verzeichnis ein. Die folgende Seite wird angezeigt: cov Wie Sie sehen können, erreichte die Codeabdeckung von main.js 100%, was darauf hinweist, dass der Test die Geschäftslogik vollständig abdeckte. Klicken main.js auf main.js , um einen detaillierteren Bericht main.js .

👉 【 Finde den Performance-Killer heraus