chai http
5.1.1
Tests d'intégration HTTP avec les assertions Chai.
expect et should interfaces Il s'agit d'un plugin complémentaire pour la bibliothèque d'assertions Chai. Installez via npm.
npm install chai-http
Utilisez ce plugin comme vous le feriez pour tous les autres 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 ) ;Pour utiliser Chai HTTP sur une page Web, veuillez utiliser la dernière version v4 pour le moment.
Chai HTTP fournit une interface pour les tests d'intégration en direct via un superagent. Pour ce faire, vous devez d’abord créer une requête vers une application ou une URL.
Lors de la construction, vous recevez une API chaînable qui vous permet de spécifier la requête http VERB (get, post, etc.) que vous souhaitez appeler.
Vous pouvez utiliser une fonction (telle qu'une application express ou connect) ou un serveur http(s) node.js comme base de votre demande. Si le serveur n'est pas en cours d'exécution, chai-http trouvera un port approprié sur lequel écouter un test donné.
Remarque : Cette fonctionnalité n'est prise en charge que sur Node.js, pas dans les navigateurs Web.
import { request } from 'chai-http' ;
request . execute ( app )
. get ( '/' ) Lors du passage d'une app à request.execute() , elle ouvrira automatiquement le serveur pour les requêtes entrantes (en appelant listen() ) et, une fois la requête effectuée, le serveur s'arrêtera automatiquement (en appelant .close() ). Si vous souhaitez garder le serveur ouvert, peut-être si vous effectuez plusieurs requêtes, vous devez appeler .keepOpen() après .request() et fermer manuellement le serveur :
import { request } from 'chai-http' ;
const requester = request . Request ( app ) . keepOpen ( )
Promise . all ( [
requester . get ( '/a' ) ,
requester . get ( '/b' ) ,
] )
. then ( responses => { /* ... */ } )
. then ( ( ) => requester . close ( ) ) Vous pouvez également utiliser une URL de base comme base de votre demande.
import { request } from 'chai-http' ;
request . execute ( 'http://localhost:8080' )
. get ( '/' ) Une fois qu'une requête est créée avec un VERBE donné (get, post, etc), vous enchaînez sur ces méthodes supplémentaires pour créer votre requête :
| Méthode | But |
|---|---|
.set(key, value) | Définir les en-têtes de requête |
.send(data) | Définir les données de la demande (le type par défaut est JSON) |
.type(dataType) | Changer le type des données envoyées depuis la méthode .send() (xml, formulaire, etc.) |
.attach(field, file, attachment) | Joindre un fichier |
.auth(username, password) | Ajouter des en-têtes d'authentification pour l'authentification de base |
.query(parmasObject) | Chainer sur certains paramètres GET |
Exemples :
.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 Dans les exemples suivants, nous utilisons la bibliothèque d'assertions Expect de Chai :
const { expect } = chai ; Pour faire la requête et affirmer sa réponse, la méthode end peut être utilisée :
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 ) ;
} ) ; Étant donné que la fonction end reçoit un rappel, les assertions sont exécutées de manière asynchrone. Par conséquent, un mécanisme doit être utilisé pour informer le framework de test que le rappel est terminé. Sinon, le test réussira avant que les assertions ne soient vérifiées.
Par exemple, dans le cadre de test Mocha, cela est accompli à l'aide du rappel done , qui signale que le rappel est terminé, et les assertions peuvent être vérifiées :
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
} ) ;
} ) ; Une fois done , Mocha attendra l'appel à done() ou l'expiration du délai d'attente. done accepte également un paramètre d'erreur lors de la signalisation de l'achèvement.
Si Promise est disponible, request devient une bibliothèque compatible Promise - et le chaînage de then s devient possible :
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 ;
} ) ; Parfois, vous devez conserver les cookies d'une requête et les envoyer avec la suivante (par exemple, lorsque vous souhaitez vous connecter avec la première requête, puis accéder ultérieurement à une ressource uniquement authentifiée). Pour cela, .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 ) ;
} ) ;
} ) ; Remarque : Le serveur démarré par request.agent(app) ne se fermera pas automatiquement suite au(x) test(s). Vous devez appeler agent.close() après vos tests pour vous assurer que votre programme se termine.
Le module HTTP Chai fournit un certain nombre d'assertions pour les interfaces expect et should .
Affirmez qu’une réponse a un statut fourni.
expect ( res ) . to . have . status ( 200 ) ; Affirmez qu’un objet Response ou Request a un en-tête. Si une valeur est fournie, l’égalité avec la valeur sera affirmée. Vous pouvez également transmettre une expression régulière pour vérifier.
Remarque : Lorsqu'elle est exécutée dans un navigateur Web, la stratégie de même origine permet uniquement à Chai HTTP de lire certains en-têtes, ce qui peut entraîner l'échec des assertions.
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 / ) ; Affirmez qu’un objet Response ou Request a des en-têtes.
Remarque : Lorsqu'elle est exécutée dans un navigateur Web, la stratégie de même origine permet uniquement à Chai HTTP de lire certains en-têtes, ce qui peut entraîner l'échec des assertions.
expect ( req ) . to . have . headers ;Affirmez qu'une chaîne représente une adresse IP valide.
expect ( '127.0.0.1' ) . to . be . an . ip ;
expect ( '2001:0db8:85a3:0000:0000:8a2e:0370:7334' ) . to . be . an . ip ; Affirmer qu'un objet Response ou Request a un type de contenu donné.
expect ( req ) . to . be . json ;
expect ( req ) . to . be . html ;
expect ( req ) . to . be . text ; Affirmez qu’un objet Response ou Request a un jeu de caractères donné.
expect ( req ) . to . have . charset ( 'utf-8' ) ; Affirmez qu’un objet Response a un code d’état de redirection.
expect ( res ) . to . redirect ;
expect ( res ) . to . not . redirect ; Affirmez qu’un objet Response redirige vers l’emplacement fourni.
expect ( res ) . to . redirectTo ( 'http://example.com' ) ;
expect ( res ) . to . redirectTo ( / ^/search/results?orderBy=desc$ / ) ; Affirmer qu'un objet Request a un paramètre de chaîne de requête avec une clé donnée, (éventuellement) égale à la valeur
expect ( req ) . to . have . param ( 'orderby' ) ;
expect ( req ) . to . have . param ( 'orderby' , 'date' ) ;
expect ( req ) . to . not . have . param ( 'limit' ) ; Affirmer qu'un objet Request ou Response a un en-tête de cookie avec une clé donnée, (éventuellement) égale à la valeur
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 est publié avec semantic-release en utilisant les plugins :
commit-analyzer pour déterminer la prochaine version à partir des messages de validation.release-notes-generator pour résumer la version danschangelog pour mettre à jour le fichier CHANGELOG.md.github pour publier une version GitHub.git pour valider les actifs de version.npm pour publier sur npm. (La licence MIT)
Copyright (c) Jake Luer [email protected]
L'autorisation est accordée par la présente, gratuitement, à toute personne obtenant une copie de ce logiciel et des fichiers de documentation associés (le « Logiciel »), d'utiliser le Logiciel sans restriction, y compris, sans limitation, les droits d'utilisation, de copie, de modification, de fusion. , publier, distribuer, accorder des sous-licences et/ou vendre des copies du Logiciel, et permettre aux personnes à qui le Logiciel est fourni de le faire, sous réserve des conditions suivantes :
L'avis de droit d'auteur ci-dessus et cet avis d'autorisation doivent être inclus dans toutes les copies ou parties substantielles du logiciel.
LE LOGICIEL EST FOURNI « TEL QUEL », SANS GARANTIE D'AUCUNE SORTE, EXPRESSE OU IMPLICITE, Y COMPRIS MAIS SANS LIMITATION LES GARANTIES DE QUALITÉ MARCHANDE, D'ADAPTATION À UN USAGE PARTICULIER ET DE NON-VIOLATION. EN AUCUN CAS LES AUTEURS OU LES TITULAIRES DES DROITS D'AUTEUR NE SERONT RESPONSABLES DE TOUTE RÉCLAMATION, DOMMAGES OU AUTRE RESPONSABILITÉ, QUE CE SOIT DANS UNE ACTION CONTRACTUELLE, DÉLIT OU AUTRE, DÉCOULANT DE, DE OU EN RELATION AVEC LE LOGICIEL OU L'UTILISATION OU D'AUTRES TRANSACTIONS DANS LE LOGICIEL.
