chai http
5.1.1
Pruebas de integración HTTP con afirmaciones de Chai.
expect y should interfaces Este es un complemento adicional para Chai Assertion Library. Instalar a través de npm.
npm install chai-http
Utilice este complemento como lo haría con todos los demás complementos de Chai.
import * as chai from "chai" ;
import chaiHttp from "chai-http" ;
chai . use ( chaiHttp ) ;
// if you need to access `request`
import { default as chaiHttp , request } from "chai-http" ;
chai . use ( chaiHttp ) ;
request . get ( ... ) . send ( ... ) ;
// or setting up an app
request . execute ( app ) ;Para utilizar Chai HTTP en una página web, utilice la última versión v4 por ahora.
Chai HTTP proporciona una interfaz para pruebas de integración en vivo a través de superagente. Para hacer esto, primero debe crear una solicitud a una aplicación o URL.
Tras la construcción, se le proporciona una API encadenable que le permite especificar la solicitud VERBO http (obtener, publicar, etc.) que desea invocar.
Puede utilizar una función (como una aplicación Express o Connect) o un servidor http(s) de Node.js como base para su solicitud. Si el servidor no se está ejecutando, chai-http encontrará un puerto adecuado para escuchar una prueba determinada.
Nota: Esta función solo es compatible con Node.js, no con navegadores web.
import { request } from 'chai-http' ;
request . execute ( app )
. get ( '/' ) Al pasar una app a request.execute() , automáticamente abrirá el servidor para solicitudes entrantes (llamando a listen() ) y, una vez que se haya realizado una solicitud, el servidor se cerrará automáticamente (llamando a .close() ). Si desea mantener el servidor abierto, tal vez si realiza varias solicitudes, debe llamar a .keepOpen() después de .request() y cerrar manualmente el servidor:
import { request } from 'chai-http' ;
const requester = request . Request ( app ) . keepOpen ( )
Promise . all ( [
requester . get ( '/a' ) ,
requester . get ( '/b' ) ,
] )
. then ( responses => { /* ... */ } )
. then ( ( ) => requester . close ( ) ) También puede utilizar una URL base como base de su solicitud.
import { request } from 'chai-http' ;
request . execute ( 'http://localhost:8080' )
. get ( '/' ) Una vez que se crea una solicitud con un VERBO determinado (obtener, publicar, etc.), encadena estos métodos adicionales para crear su solicitud:
| Método | Objetivo |
|---|---|
.set(key, value) | Establecer encabezados de solicitud |
.send(data) | Establecer datos de solicitud (el tipo predeterminado es JSON) |
.type(dataType) | Cambiar el tipo de datos enviados desde el método .send() (xml, formulario, etc.) |
.attach(field, file, attachment) | Adjuntar un archivo |
.auth(username, password) | Agregue encabezados de autenticación para la autenticación básica |
.query(parmasObject) | Cadena en algunos parámetros GET |
Ejemplos:
.set()
import { request } from 'chai-http' ;
// Set a request header
request . execute ( app )
. put ( '/user/me' )
. set ( 'Content-Type' , 'application/json' )
. send ( { password : '123' , confirmPassword : '123' } ) .send()
import { request } from 'chai-http' ;
// Send some JSON
request . execute ( app )
. put ( '/user/me' )
. send ( { password : '123' , confirmPassword : '123' } ) .type()
import { request } from 'chai-http' ;
// Send some Form Data
request . execute ( app )
. post ( '/user/me' )
. type ( 'form' )
. send ( {
'_method' : 'put' ,
'password' : '123' ,
'confirmPassword' : '123'
} ) .attach()
import { request } from 'chai-http' ;
// Attach a file
request . execute ( app )
. post ( '/user/avatar' )
. attach ( 'imageField' , fs . readFileSync ( 'avatar.png' ) , 'avatar.png' ) .auth()
import { request } from 'chai-http' ;
// Authenticate with Basic authentication
request . execute ( app )
. get ( '/protected' )
. auth ( 'user' , 'pass' )
// Authenticate with Bearer Token
request . execute ( app )
. get ( '/protected' )
. auth ( accessToken , { type : 'bearer' } ) .query()
import { request } from 'chai-http' ;
// Chain some GET query parameters
request . execute ( app )
. get ( '/search' )
. query ( { name : 'foo' , limit : 10 } ) // /search?name=foo&limit=10 En los siguientes ejemplos utilizamos la biblioteca de aserciones Expect de Chai:
const { expect } = chai ; Para realizar la solicitud y hacer valer su respuesta, se puede utilizar el método end :
import { request } from 'chai-http' ;
request . execute ( app )
. put ( '/user/me' )
. send ( { password : '123' , confirmPassword : '123' } )
. end ( ( err , res ) => {
expect ( err ) . to . be . null ;
expect ( res ) . to . have . status ( 200 ) ;
} ) ; Debido a que a la función end se le pasa una devolución de llamada, las aserciones se ejecutan de forma asincrónica. Por lo tanto, se debe utilizar un mecanismo para notificar al marco de prueba que la devolución de llamada se ha completado. De lo contrario, la prueba pasará antes de que se verifiquen las afirmaciones.
Por ejemplo, en el marco de prueba de Mocha, esto se logra usando la devolución de llamada done , que indica que la devolución de llamada se ha completado y las afirmaciones se pueden verificar:
import { request } from 'chai-http' ;
it ( 'fails, as expected' , function ( done ) { // <= Pass in done callback
request . execute ( 'http://localhost:8080' )
. get ( '/' )
. end ( ( err , res ) => {
expect ( res ) . to . have . status ( 123 ) ;
done ( ) ; // <= Call done to signal callback end
} ) ;
} ) ;
it ( 'succeeds silently!' , ( ) => { // <= No done callback
request . execute ( 'http://localhost:8080' )
. get ( '/' )
. end ( ( err , res ) => {
expect ( res ) . to . have . status ( 123 ) ; // <= Test completes before this runs
} ) ;
} ) ; Cuando se pasa done , Mocha esperará hasta que se llame a done() o hasta que expire el tiempo de espera. done también acepta un parámetro de error al señalar la finalización.
Si Promise está disponible, request se convierte en una biblioteca compatible con Promise y es then encadenar s:
import { request } from 'chai-http' ;
request . execute ( app )
. put ( '/user/me' )
. send ( { password : '123' , confirmPassword : '123' } )
. then ( ( res ) => {
expect ( res ) . to . have . status ( 200 ) ;
} )
. catch ( ( err ) => {
throw err ;
} ) ; A veces es necesario conservar las cookies de una solicitud y enviarlas con la siguiente (por ejemplo, cuando desea iniciar sesión con la primera solicitud y luego acceder a un recurso solo autenticado). Para ello, .request.agent() está disponible:
import { request } from 'chai-http' ;
// Log in
const agent = request . agent ( app )
agent
. post ( '/session' )
. send ( { username : 'me' , password : '123' } )
. then ( ( res ) => {
expect ( res ) . to . have . cookie ( 'sessionid' ) ;
// The `agent` now has the sessionid cookie saved, and will send it
// back to the server in the next request:
return agent . get ( '/user/me' )
. then ( ( res ) => {
expect ( res ) . to . have . status ( 200 ) ;
} ) ;
} ) ; Nota: El servidor iniciado por request.agent(app) no se cerrará automáticamente después de las pruebas. Debe llamar agent.close() después de sus pruebas para asegurarse de que su programa salga.
El módulo HTTP Chai proporciona una serie de afirmaciones para las interfaces expect y should .
Afirmar que una respuesta tiene un estado suministrado.
expect ( res ) . to . have . status ( 200 ) ; Afirma que un objeto Response o Request tiene un encabezado. Si se proporciona un valor, se afirmará la igualdad con el valor. También puedes pasar una expresión regular para verificar.
Nota: Cuando se ejecuta en un navegador web, la política del mismo origen solo permite que Chai HTTP lea ciertos encabezados, lo que puede provocar que las aserciones fallen.
expect ( req ) . to . have . header ( 'x-api-key' ) ;
expect ( req ) . to . have . header ( 'content-type' , 'text/plain' ) ;
expect ( req ) . to . have . header ( 'content-type' , / ^text / ) ; Afirmar que un objeto Response o Request tiene encabezados.
Nota: Cuando se ejecuta en un navegador web, la política del mismo origen solo permite que Chai HTTP lea ciertos encabezados, lo que puede provocar que las aserciones fallen.
expect ( req ) . to . have . headers ;Afirma que una cadena representa una dirección IP válida.
expect ( '127.0.0.1' ) . to . be . an . ip ;
expect ( '2001:0db8:85a3:0000:0000:8a2e:0370:7334' ) . to . be . an . ip ; Afirma que un objeto Response o Request tiene un tipo de contenido determinado.
expect ( req ) . to . be . json ;
expect ( req ) . to . be . html ;
expect ( req ) . to . be . text ; Afirma que un objeto Response o Request tiene un juego de caracteres determinado.
expect ( req ) . to . have . charset ( 'utf-8' ) ; Afirma que un objeto Response tiene un código de estado de redireccionamiento.
expect ( res ) . to . redirect ;
expect ( res ) . to . not . redirect ; Afirma que un objeto Response redirige a la ubicación proporcionada.
expect ( res ) . to . redirectTo ( 'http://example.com' ) ;
expect ( res ) . to . redirectTo ( / ^/search/results?orderBy=desc$ / ) ; Afirmar que un objeto Request tiene un parámetro de cadena de consulta con una clave determinada, (opcionalmente) igual al valor
expect ( req ) . to . have . param ( 'orderby' ) ;
expect ( req ) . to . have . param ( 'orderby' , 'date' ) ;
expect ( req ) . to . not . have . param ( 'limit' ) ; Afirmar que un objeto Request o Response tiene un encabezado de cookie con una clave determinada, (opcionalmente) igual al valor
expect ( req ) . to . have . cookie ( 'session_id' ) ;
expect ( req ) . to . have . cookie ( 'session_id' , '1234' ) ;
expect ( req ) . to . not . have . cookie ( 'PHPSESSID' ) ;
expect ( res ) . to . have . cookie ( 'session_id' ) ;
expect ( res ) . to . have . cookie ( 'session_id' , '1234' ) ;
expect ( res ) . to . not . have . cookie ( 'PHPSESSID' ) ; chai-http se lanza con semantic-release usando los complementos:
commit-analyzer para determinar la próxima versión a partir de los mensajes de confirmación.release-notes-generator para resumir la versión enchangelog para actualizar el archivo CHANGELOG.md.github para publicar una versión de GitHub.git para confirmar los activos de liberación.npm para publicar en npm. (La licencia MIT)
Copyright (c) Jake Luer [email protected]
Por el presente se otorga permiso, sin cargo, a cualquier persona que obtenga una copia de este software y los archivos de documentación asociados (el "Software"), para operar con el Software sin restricciones, incluidos, entre otros, los derechos de uso, copia, modificación, fusión. , publicar, distribuir, sublicenciar y/o vender copias del Software, y permitir que las personas a quienes se les proporciona el Software lo hagan, sujeto a las siguientes condiciones:
El aviso de derechos de autor anterior y este aviso de permiso se incluirán en todas las copias o partes sustanciales del Software.
EL SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA, INCLUYENDO, PERO NO LIMITADO A, LAS GARANTÍAS DE COMERCIABILIDAD, IDONEIDAD PARA UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN. EN NINGÚN CASO LOS AUTORES O TITULARES DE DERECHOS DE AUTOR SERÁN RESPONSABLES DE NINGÚN RECLAMO, DAÑO U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN CONTRACTUAL, AGRAVIO O DE OTRA MANERA, QUE SURJA DE, FUERA DE O EN RELACIÓN CON EL SOFTWARE O EL USO U OTRAS NEGOCIOS EN EL SOFTWARE.
