Unha boa vida comeza coa proba

Un programador que non escribe casos de proba automáticos non é un bo enxeñeiro de probas. Animamos a todos os proxectos a establecer casos de proba automáticos completos desde o principio. Co desenvolvemento do proxecto, o investimento inicial será recompensado centos de veces.

Continuemos co exemplo da sección anterior e botemos unha ollada a como usar fibjs para escribir casos de proba.

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 marco de proba baleiro

Comecemos cun marco básico de probas:

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

Gardar como test.jsmáis tarde, na liña de comandos fibjs test.js, verá a seguinte saída, escribiuse un marco de proba básico.

1
2
3
4
  hello, test
    √ a empty test

  √ 1 tests completed (0ms)

Inicia o servidor de proba

Debido a que necesitamos probar o servidor http, primeiro debemos iniciar o servidor. O caso de proba enviará unha solicitude ao servidor e, a continuación, probará o resultado da solicitude para determinar se o servidor cumpre os requisitos:

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

Neste código, xulgamos se a lóxica do servidor é normal verificando se o resultado de http.get é o resultado que esperamos. Segundo este exemplo, podemos completar rapidamente un conxunto de probas e optimizamos o código ao mesmo 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();

Xestión grupal de casos de uso

Engadimos a proba de bonjour. Aínda que bonjour e hola son o mesmo conxunto de servizos, porque o camiño cambiou, tamén necesitamos verificar a corrección do servizo. Esta vez, para xestionar mellor os casos de uso, realizamos os casos de proba Agrupando, ao mesmo tempo, porque o contido da proba de hello e bonjour son os mesmos, optimizamos de novo o código e probamos os dous conxuntos de servizos co mesmo conxunto de códigos:

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

A través da agrupación de casos de uso, podemos ver os resultados das probas con maior claridade e tamén é fácil saltar e probar un grupo de casos de uso individualmente, acelerando o desenvolvemento e probando a velocidade. Os seguintes son os resultados desta rolda de probas:

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)

Segundo o deseño do noso servidor, tamén temos un conxunto de servizos de ficheiros estáticos. Segundo o exemplo anterior, creo que pode escribir rapidamente esta parte dos casos de proba.

Proba cun só clic

Despois da introdución anterior, podemos establecer rápidamente casos de proba. Pero para usar este script de proba, primeiro ten que iniciar o servidor, isto é moi sinxelo, queremos executalo test.jspara completar a proba directamente. Podemos usar o seguinte código para lograr:

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

Liña 6 a 10 deste código, engadimos un main.jscódigo de inicio de parágrafo e agardamos un pouco e reiniciamos as probas.

Comprobación da cobertura do código

Os bos casos de proba deben ter en conta que os casos de proba deben cubrir todas as ramas da empresa para asegurarse de que a empresa se executa correctamente. Neste momento, pódense utilizar comprobacións de cobertura de código para determinar se a proba está completa.

Este proceso é moi sinxelo, só tes que engadir o parámetro --cov ao probar:

1
fibjs --cov test

Despois de completar a proba, xerarase un ficheiro de rexistro de fibjs-xxxx.lcov no directorio actual. Neste momento, é necesario analizar o rexistro e xerar un informe:

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

Entón pode xerar un conxunto de informes de análise no directorio out. Entre no catálogo para comprobar, podes ver a seguinte páxina: Podes ver que main.jsa cobertura do código alcanzou o 100%, o que significa que a proba cobre completamente a lóxica de negocio. Fai clic para main.jsver un informe máis detallado.

👉 [ Atopa o asesino de rendemento ]