Guida allo sviluppo della guida
  1. prima pagina
  2. guida allo sviluppo
  3. Una vita migliore inizia con una prova

Una vita migliore inizia con una prova

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

Continuiamo l'esempio nella sezione precedente per vedere come scrivere un test case usando fibjs.

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 framework di test vuoto

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

test.jsDopo averlo salvato con nome ed eseguito sulla riga di comando fibjs test.js, 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)

avviare 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, valutiamo se la logica del server è normale verificando se il risultato di http.get è quello che ci aspettavamo. Seguendo questo esempio, possiamo completare rapidamente una serie di test e ottimizzare un po' il codice allo stesso tempo:

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

Successivamente, 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 testato i casi di test Raggruppamento, allo stesso tempo, poiché il contenuto del test di hello e bonjour è lo stesso, abbiamo ottimizzato nuovamente il codice e testato due gruppi di servizi con lo stesso set di 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
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 e possiamo anche saltare facilmente e testare un gruppo di casi d'uso separatamente per accelerare lo sviluppo e il test. Ecco i risultati di questo round 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)

Secondo il nostro design del 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 a una chiave

Dopo l'introduzione di cui sopra, possiamo creare rapidamente casi di test. Ma per utilizzare questo script di test, il server deve essere avviato prima, il che è molto scomodo.Ci auguriamo che l'esecuzione test.jspossa completare direttamente il test. Possiamo farlo con il seguente 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
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 main.jsdi avvio e abbiamo aspettato un po' prima di iniziare il test.

controllo della copertura del codice

Un buon caso di test deve considerare che il caso di test deve 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 registro fibjs-xxxx.lcov, a questo punto è necessario analizzare il registro e generare un rapporto:

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

È possibile generare una serie di report di analisi nella directory out. Entra nella directory da controllare e vedrai la seguente pagina: cov Come puoi vedere, main.jsla copertura del codice del test ha raggiunto il 100%, indicando che il test copre completamente la business logic. Fare clic su main.jsUlteriori per visualizzare un rapporto più dettagliato.

👉【Trova il killer delle prestazioni】

© Copyright 2012-2021 fibjs.org | Sostienici