Ein gutes Leben beginnt mit dem Testen

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

Nachdem Sie es als test.js , führen Sie 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 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
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. Anhand dieses Beispiels können wir schnell eine Reihe von Tests durchführen und 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();

Gruppenverwaltung von Anwendungsfällen

Fügen wir den Bonjour-Test 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 die Testfälle durchgeführt, um die Anwendungsfälle besser verwalten zu können Gleichzeitig haben wir den Code erneut optimiert und die beiden Servicesätze mit demselben Codesatz 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
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 es ist auch einfach, eine Gruppe von Anwendungsfällen einzeln zu überspringen und zu testen, um die Entwicklung und das Testen 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 meines Erachtens schnell ausschreiben.

Ein-Klick-Test

Nach der obigen 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 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-10 dieses Codes haben wir einen Codeabschnitt hinzugefügt, um main.js zu starten, und eine Weile gewartet, bevor wir den Test gestartet main.js .

Ü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 können mithilfe von Überprüfungen der Codeabdeckung festgestellt werden, ob der Test abgeschlossen 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 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:

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

Anschließend können Sie eine Reihe von Analyseberichten im Verzeichnis out erstellen. Geben Sie den Katalog ein, um ihn anzuzeigen. Die folgende Seite wird angezeigt: Wie Sie sehen können, erreicht die Codeabdeckung von main.js 100%, was darauf hinweist, dass der Test die Geschäftslogik vollständig abdeckt. Klicken main.js weiter auf main.js , um einen detaillierteren Bericht main.js .

👉 [ Finde den Performance-Killer ]