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
21const 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
10var test = require('test');
test.setup();
describe('hello, test', () => {
it('a empty test', () => {
});
});
test.run();
Gardar como test.js
má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
14var 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
30var 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
37var 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.js
para 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
43var 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.js
có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:
1fibjs --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:
1fibjs --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.js
a cobertura do código alcanzou o 100%, o que significa que a proba cobre completamente a lóxica de negocio. Fai clic para main.js
ver un informe máis detallado.