Guía de desarrollo de la guía

La buena vida comienza con la prueba.

Un programador que no escribe casos de prueba automatizados no es un buen ingeniero de pruebas. Alentamos a todos los proyectos a establecer casos de prueba automatizados completos desde el principio. Con el desarrollo del proyecto, la inversión inicial se devolverá cientos de veces.

Continuemos con el ejemplo de la sección anterior y veamos cómo escribir casos de prueba 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 marco de prueba vacío

Comencemos con un marco de prueba básico:

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

Después de guardar como test.js , ejecute fibjs test.js en la línea de comando, verá el siguiente resultado y se escribirá un marco de prueba básico.

1 2 3 4
hello, test √ a empty test √ 1 tests completed (0ms)

Comience a probar el servidor

Debido a que necesitamos probar el servidor http, primero debemos iniciar el servidor. El caso de prueba envía una solicitud al servidor y luego prueba el resultado de la solicitud para determinar si el servidor cumple con los 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();

En este código, determinamos si la lógica del servidor es normal verificando que el resultado de http.get sea el esperado. Siguiendo este ejemplo, podemos completar rápidamente un conjunto de pruebas. También optimizamos el código al mismo tiempo:

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

Agrupación de casos de uso

Agreguemos una prueba de bonjour. Aunque bonjour y hello son el mismo conjunto de servicios, porque la ruta ha cambiado, también debemos verificar la exactitud del servicio. Esta vez, para gestionar mejor los casos de uso, realizamos casos de prueba Al mismo tiempo, debido a que el contenido de prueba de hello y bonjour es el mismo, optimizamos el código nuevamente y probamos los dos conjuntos de servicios con el mismo conjunto 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();

Al agrupar los casos de uso, podemos ver los resultados de la prueba más claramente, y podemos omitir y probar fácilmente un grupo de casos de uso individualmente para acelerar el desarrollo y la velocidad de la prueba. Aquí están los resultados de esta ronda de pruebas:

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)

Según el diseño de nuestro servidor, también tenemos un conjunto de servicios de archivos estáticos. Según el ejemplo anterior, creo que puede escribir rápidamente esta parte del caso de prueba.

Prueba de un clic

Después de la introducción anterior, podemos construir rápidamente casos de prueba. Sin embargo, para utilizar este script de prueba, primero se debe iniciar el servidor, lo cual es muy inconveniente. Esperamos que ejecutar test.js pueda completar directamente la prueba. Podemos lograr esto con el siguiente código:

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

En las líneas 6 a 10 de este código, agregamos un fragmento de código para iniciar main.js , y esperamos un poco antes de comenzar a probar.

Código de verificación de cobertura

Los buenos casos de prueba deben tener en cuenta que los casos de prueba deben cubrir todas las ramas de la empresa para determinar si la empresa se está ejecutando correctamente. En este momento, puede utilizar las verificaciones de cobertura de código para determinar si la prueba se ha completado.

El proceso es simple, solo agregue el parámetro --cov cuando pruebe:

1
fibjs --cov test

Una vez completada la prueba, se generará un archivo de registro de fibjs-xxxx.lcov en el directorio actual. En este momento, el registro debe analizarse y se debe generar un informe:

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

Se puede generar un conjunto de informes de análisis en el directorio de salida. Ingrese al directorio para ver las siguientes páginas: cov Puede ver que la cobertura de código de main.js ha alcanzado el 100%, lo que significa que la prueba cubre completamente la lógica de negocios. Haga clic en main.js para ver informes más detallados.

👉 [ Descubre el asesino de rendimiento ]