chai http
5.1.1
Teste de integração HTTP com asserções Chai.
expect e should interfaces Este é um plugin adicional para a Biblioteca Chai Assertion. Instale via npm.
npm install chai-http
Use este plugin como faria com todos os outros plugins 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 usar Chai HTTP em uma página da web, use a versão v4 mais recente por enquanto.
Chai HTTP fornece uma interface para testes de integração ao vivo via superagente. Para fazer isso, você deve primeiro construir uma solicitação para um aplicativo ou URL.
Após a construção, você recebe uma API encadeada que permite especificar a solicitação HTTP VERB (get, post, etc.) que deseja invocar.
Você pode usar uma função (como um aplicativo expresso ou de conexão) ou um servidor http(s) node.js como base para sua solicitação. Se o servidor não estiver em execução, o chai-http encontrará uma porta adequada para escutar um determinado teste.
Observação: esse recurso é compatível apenas com Node.js, e não em navegadores da web.
import { request } from 'chai-http' ;
request . execute ( app )
. get ( '/' ) Ao passar um app para request.execute() , ele abrirá automaticamente o servidor para solicitações recebidas (chamando listen() ) e, uma vez feita uma solicitação, o servidor será desligado automaticamente (chamando .close() ). Se você quiser manter o servidor aberto, talvez se estiver fazendo várias solicitações, você deve chamar .keepOpen() depois de .request() e fechar manualmente o 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 ( ) ) Você também pode usar um URL base como base de sua solicitação.
import { request } from 'chai-http' ;
request . execute ( 'http://localhost:8080' )
. get ( '/' ) Depois que uma solicitação é criada com um determinado VERBO (get, post, etc), você encadeia estes métodos adicionais para criar sua solicitação:
| Método | Propósito |
|---|---|
.set(key, value) | Definir cabeçalhos de solicitação |
.send(data) | Definir dados de solicitação (o tipo padrão é JSON) |
.type(dataType) | Altere o tipo de dados enviados do método .send() (xml, formulário, etc) |
.attach(field, file, attachment) | Anexe um arquivo |
.auth(username, password) | Adicione cabeçalhos de autenticação para autenticação básica |
.query(parmasObject) | Cadeia em alguns parâmetros GET |
Exemplos:
.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 Nos exemplos a seguir, usamos a biblioteca de asserções Expect de Chai:
const { expect } = chai ; Para fazer a solicitação e afirmar sua resposta, o método end pode ser usado:
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 ) ;
} ) ; Como a função end recebe um retorno de chamada, as asserções são executadas de forma assíncrona. Portanto, um mecanismo deve ser usado para notificar a estrutura de teste de que o retorno de chamada foi concluído. Caso contrário, o teste será aprovado antes que as afirmações sejam verificadas.
Por exemplo, na estrutura de teste Mocha, isso é feito usando o retorno de chamada done , que sinaliza que o retorno de chamada foi concluído e as asserções podem ser verificadas:
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
} ) ;
} ) ; Quando done for transmitido, o Mocha aguardará até que a chamada para done() ou até que o tempo limite expire. done também aceita um parâmetro de erro ao sinalizar a conclusão.
Se Promise estiver disponível, request se tornará uma biblioteca compatível com Promise - e o encadeamento de then s se tornará possível:
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 ;
} ) ; Às vezes, você precisa manter os cookies de uma solicitação e enviá-los na próxima (por exemplo, quando quiser fazer login na primeira solicitação e acessar um recurso somente autenticado posteriormente). Para isso, .request.agent() está disponível:
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: O servidor iniciado por request.agent(app) não será fechado automaticamente após o(s) teste(s). Você deve chamar agent.close() após seus testes para garantir que seu programa seja encerrado.
O módulo Chai HTTP fornece uma série de asserções para as interfaces expect e should .
Afirme que uma resposta tem um status fornecido.
expect ( res ) . to . have . status ( 200 ) ; Afirme que um objeto Response ou Request possui um cabeçalho. Se um valor for fornecido, a igualdade ao valor será afirmada. Você também pode passar uma expressão regular para verificar.
Nota: Ao executar em um navegador da web, a política de mesma origem permite apenas que o Chai HTTP leia determinados cabeçalhos, o que pode causar falhas nas asserções.
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 / ) ; Afirme que um objeto Response ou Request possui cabeçalhos.
Nota: Ao executar em um navegador da web, a política de mesma origem permite apenas que o Chai HTTP leia determinados cabeçalhos, o que pode causar falhas nas asserções.
expect ( req ) . to . have . headers ;Afirme que uma string representa um endereço IP válido.
expect ( '127.0.0.1' ) . to . be . an . ip ;
expect ( '2001:0db8:85a3:0000:0000:8a2e:0370:7334' ) . to . be . an . ip ; Afirme que um objeto Response ou Request possui um determinado tipo de conteúdo.
expect ( req ) . to . be . json ;
expect ( req ) . to . be . html ;
expect ( req ) . to . be . text ; Afirme que um objeto Response ou Request possui um determinado conjunto de caracteres.
expect ( req ) . to . have . charset ( 'utf-8' ) ; Afirme que um objeto Response possui um código de status de redirecionamento.
expect ( res ) . to . redirect ;
expect ( res ) . to . not . redirect ; Afirme que um objeto Response redireciona para o local fornecido.
expect ( res ) . to . redirectTo ( 'http://example.com' ) ;
expect ( res ) . to . redirectTo ( / ^/search/results?orderBy=desc$ / ) ; Afirme que um objeto Request possui um parâmetro de string de consulta com uma determinada chave, (opcionalmente) igual ao valor
expect ( req ) . to . have . param ( 'orderby' ) ;
expect ( req ) . to . have . param ( 'orderby' , 'date' ) ;
expect ( req ) . to . not . have . param ( 'limit' ) ; Afirme que um objeto Request ou Response possui um cabeçalho de cookie com uma determinada chave, (opcionalmente) igual ao 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 é lançado com semantic-release usando os plugins:
commit-analyzer para determinar a próxima versão das mensagens de commit.release-notes-generator para resumir o lançamento emchangelog para atualizar o arquivo CHANGELOG.md.github para publicar uma versão do GitHub.git para confirmar os ativos de lançamento.npm para publicar no npm. (A licença MIT)
Direitos autorais (c) Jake Luer [email protected]
É concedida permissão, gratuitamente, a qualquer pessoa que obtenha uma cópia deste software e dos arquivos de documentação associados (o "Software"), para negociar o Software sem restrições, incluindo, sem limitação, os direitos de usar, copiar, modificar, mesclar , publicar, distribuir, sublicenciar e/ou vender cópias do Software e permitir que as pessoas a quem o Software seja fornecido o façam, sujeito às seguintes condições:
O aviso de direitos autorais acima e este aviso de permissão serão incluídos em todas as cópias ou partes substanciais do Software.
O SOFTWARE É FORNECIDO "COMO ESTÁ", SEM GARANTIA DE QUALQUER TIPO, EXPRESSA OU IMPLÍCITA, INCLUINDO, MAS NÃO SE LIMITANDO ÀS GARANTIAS DE COMERCIALIZAÇÃO, ADEQUAÇÃO A UM DETERMINADO FIM E NÃO VIOLAÇÃO. EM NENHUM CASO OS AUTORES OU DETENTORES DE DIREITOS AUTORAIS SERÃO RESPONSÁVEIS POR QUALQUER RECLAMAÇÃO, DANOS OU OUTRA RESPONSABILIDADE, SEJA EM UMA AÇÃO DE CONTRATO, ATO ILÍCITO OU DE OUTRA FORMA, DECORRENTE DE, OU EM CONEXÃO COM O SOFTWARE OU O USO OU OUTRAS NEGOCIAÇÕES NO SOFTWARE.
