Ein gutes Leben beginnt mit der Prüfung

Ein Programmierer, der keine automatischen Testfälle schreibt, ist kein guter Testingenieur. Wir ermutigen alle Projekte, von Anfang an vollständig automatisierte Testfälle zu etablieren. Mit der Entwicklung des Projekts wird die Anfangsinvestition hundertfach belohnt.

Lassen Sie uns das Beispiel aus dem vorherigen Abschnitt fortsetzen und einen Blick darauf werfen, wie Sie fibjs zum Schreiben von Testfällen verwenden.

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

Speichern Sie als test.jsspäter in der Befehlszeile fibjs test.jsdie folgende Ausgabe, ein grundlegendes Test-Framework wurde geschrieben.

1
2
3
4
  hello, test
    √ a empty test

  √ 1 tests completed (0ms)

Testserver starten

Da wir den http-Server testen müssen, müssen wir zuerst den Server starten. Der Testfall sendet eine Anfrage an den Server und testet dann das Ergebnis der Anfrage, 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 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 haben gleichzeitig 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();

Gruppenverwaltung von Anwendungsfällen

Fügen wir den Bonjour-Test hinzu. Obwohl bonjour und hello die gleichen Dienste sind, müssen wir auch die Korrektheit des Dienstes ü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 gruppieren, da die Testinhalte von hello und bonjour gleich sind, haben wir den Code erneut optimiert und die beiden Dienste mit dem gleichen Codesatz 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 das Gruppieren von Anwendungsfällen können wir die Testergebnisse klarer anzeigen, und es ist auch einfach, eine Gruppe von Anwendungsfällen einzeln zu überspringen und zu testen, um die Entwicklung und das Testen zu beschleunigen. Das 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)

Gemäß unserem Serverdesign haben wir auch eine Reihe von statischen Dateidiensten.Nach obigem Beispiel kann man diesen Teil der Testfälle meiner Meinung nach schnell ausschreiben.

Ein-Klick-Test

Nach der obigen Einführung können wir schnell Testfälle erstellen. Aber um dieses Testskript zu verwenden, müssen Sie zuerst den Server starten, dies ist sehr einfach, wir möchten test.jsden Test direkt ausführen , um den Test abzuschließen. Wir können den folgenden Code verwenden, um Folgendes 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 Absatzstartcode hinzugefügt main.js, etwas gewartet und dann die Tests neu gestartet.

Überprüfung der Codeabdeckung

Gute Testfälle müssen berücksichtigen, dass die Testfälle jeden Geschäftszweig abdecken müssen, um sicherzustellen, dass das Geschäft korrekt ausgeführt wird.Zu diesem Zeitpunkt kann die Überprüfung der Codeabdeckung verwendet werden, um festzustellen, ob der Test vollständig ist.

Dieser Vorgang ist sehr einfach, fügen Sie beim Testen einfach den Parameter --cov hinzu:

1
fibjs --cov test

Nach Abschluss des Tests wird im aktuellen Verzeichnis eine Protokolldatei fibjs-xxxx.lcov erstellt. 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 im Ausgangsverzeichnis eine Reihe von Analyseberichten generieren. Geben Sie den zu prüfenden Katalog ein, Sie sehen die folgende Seite: cov Sie 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.

👉 [ Finde den Leistungskiller ]

Entwicklungsleitfaden

Basismodul

Eingebaute Objekte

Community-Modul