Una buona vita inizia con i test

Un programmatore che non scrive casi di test automatici non è un buon ingegnere di test. Incoraggiamo tutti i progetti a stabilire fin dall'inizio casi di test automatizzati completi. Con lo sviluppo del progetto, l'investimento iniziale verrà premiato centinaia di volte.

Continuiamo l'esempio della sezione precedente e diamo un'occhiata a come usare fibjs per scrivere casi di test.

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

Un frame di prova vuoto

Cominciamo con un framework di test di base:

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

Dopo averlo salvato come test.js , esegui fibjs test.js sulla riga di comando, vedrai il seguente output e verrà scritto un framework di test di base.

1
2
3
4
  hello, test
    √ a empty test

  √ 1 tests completed (0ms)

Avvia il server di prova

Poiché dobbiamo testare il server http, dobbiamo prima avviare il server. Il test case invierà una richiesta al server, quindi testerà il risultato della richiesta per determinare se il server soddisfa i requisiti:

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 questo codice, giudichiamo se la logica del server è normale verificando se il risultato di http.get è il risultato che ci aspettiamo. Secondo questo esempio, possiamo completare rapidamente una serie di test e abbiamo anche ottimizzato il codice:

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

Gestione di gruppo dei casi d'uso

Aggiungiamo il test bonjour. Sebbene bonjour e hello siano lo stesso insieme di servizi, poiché il percorso è cambiato, dobbiamo anche verificare la correttezza del servizio. Questa volta, per gestire al meglio i casi d'uso, abbiamo eseguito i casi di test Raggruppando, allo stesso tempo, poiché il contenuto di prova di hello e bonjour è lo stesso, abbiamo ottimizzato nuovamente il codice e testato i due set di servizi con lo stesso set di codici:

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

Raggruppando i casi d'uso, possiamo visualizzare i risultati del test in modo più chiaro ed è anche facile saltare e testare individualmente un gruppo di casi d'uso per accelerare lo sviluppo e il test. I seguenti sono i risultati di questo ciclo di test:

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)

In base al design del nostro server, abbiamo anche una serie di servizi di file statici Secondo l'esempio sopra, credo che tu possa scrivere rapidamente questa parte dei casi di test.

Test con un clic

Dopo l'introduzione di cui sopra, possiamo stabilire rapidamente casi di test. Ma per poter utilizzare questo script di test, il server deve essere avviato prima, il che è molto test.js che l'esecuzione di test.js possa completare direttamente il test. Possiamo usare il seguente codice per ottenere:

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

Nelle righe 6-10 di questo codice, abbiamo aggiunto una sezione di codice per avviare main.js e abbiamo aspettato un po 'prima di iniziare il test.

Controllo della copertura del codice

I casi di test validi devono considerare che i casi di test devono coprire ogni ramo dell'azienda per garantire che l'attività venga eseguita correttamente. A questo punto, è possibile utilizzare i controlli di copertura del codice per determinare se il test è completo.

Questo processo è molto semplice, basta aggiungere il parametro --cov durante il test:

1
fibjs --cov test

Al termine del test, nella directory corrente verrà generato un file di log di fibjs-xxxx.lcov. A questo punto, è necessario analizzare il log e generare un report:

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

Quindi è possibile generare una serie di report di analisi nella directory out. Entra nel catalogo da visualizzare, puoi vedere la seguente pagina: Come puoi vedere, la copertura del codice di main.js raggiunge il 100%, indicando che il test copre completamente la logica di business. Fare main.js ulteriormente su main.js per visualizzare un rapporto più dettagliato.

👉 [ Trova il killer delle prestazioni ]