chai http
5.1.1
HTTP-Integrationstests mit Chai-Behauptungen.
expect und should Schnittstellen Dies ist ein Add-on-Plugin für die Chai Assertion Library. Über npm installieren.
npm install chai-http
Verwenden Sie dieses Plugin wie alle anderen Chai-Plugins.
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 ) ;Um Chai HTTP auf einer Webseite zu verwenden, verwenden Sie bitte vorerst die neueste v4-Version.
Chai HTTP bietet eine Schnittstelle für Live-Integrationstests über Superagent. Dazu müssen Sie zunächst eine Anfrage an eine Anwendung oder URL erstellen.
Bei der Erstellung erhalten Sie eine verkettbare API, mit der Sie die http-VERB-Anfrage (get, post usw.) angeben können, die Sie aufrufen möchten.
Sie können eine Funktion (z. B. eine Express- oder Connect-App) oder einen http(s)-Server von node.js als Grundlage für Ihre Anfrage verwenden. Wenn der Server nicht läuft, findet chai-http einen geeigneten Port zum Abhören für einen bestimmten Test.
Hinweis: Diese Funktion wird nur auf Node.js unterstützt, nicht in Webbrowsern.
import { request } from 'chai-http' ;
request . execute ( app )
. get ( '/' ) Wenn eine app an request.execute() übergeben wird, öffnet sie automatisch den Server für eingehende Anfragen (durch Aufruf von listen() ) und sobald eine Anfrage gestellt wurde, wird der Server automatisch heruntergefahren (durch Aufruf von .close() ). Wenn Sie den Server offen halten möchten, beispielsweise wenn Sie mehrere Anfragen stellen, müssen Sie .keepOpen() nach .request() aufrufen und den Server manuell schließen:
import { request } from 'chai-http' ;
const requester = request . Request ( app ) . keepOpen ( )
Promise . all ( [
requester . get ( '/a' ) ,
requester . get ( '/b' ) ,
] )
. then ( responses => { /* ... */ } )
. then ( ( ) => requester . close ( ) ) Sie können auch eine Basis-URL als Grundlage für Ihre Anfrage verwenden.
import { request } from 'chai-http' ;
request . execute ( 'http://localhost:8080' )
. get ( '/' ) Sobald eine Anfrage mit einem bestimmten VERB (get, post usw.) erstellt wurde, verketten Sie diese zusätzlichen Methoden, um Ihre Anfrage zu erstellen:
| Verfahren | Zweck |
|---|---|
.set(key, value) | Legen Sie Anforderungsheader fest |
.send(data) | Anforderungsdaten festlegen (Standardtyp ist JSON) |
.type(dataType) | Ändern Sie den Typ der von der .send() -Methode gesendeten Daten (XML, Formular usw.). |
.attach(field, file, attachment) | Hängen Sie eine Datei an |
.auth(username, password) | Fügen Sie Authentifizierungsheader für die Standardauthentifizierung hinzu |
.query(parmasObject) | Verketten Sie einige GET-Parameter |
Beispiele:
.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 In den folgenden Beispielen verwenden wir die Expect-Assertionsbibliothek von Chai:
const { expect } = chai ; Um die Anfrage zu stellen und ihre Antwort zu bestätigen, kann die end Methode verwendet werden:
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 ) ;
} ) ; Da der end ein Rückruf übergeben wird, werden Zusicherungen asynchron ausgeführt. Daher muss ein Mechanismus verwendet werden, um das Testframework darüber zu informieren, dass der Rückruf abgeschlossen ist. Andernfalls wird der Test bestanden, bevor die Behauptungen überprüft werden.
Im Mocha-Testframework wird dies beispielsweise mithilfe des done -Callbacks erreicht, der signalisiert, dass der Callback abgeschlossen ist, und die Behauptungen können überprüft werden:
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
} ) ;
} ) ; Wenn done übergeben wird, wartet Mocha bis zum Aufruf von done() oder bis zum Ablauf des Timeouts. done akzeptiert auch einen Fehlerparameter, wenn der Abschluss signalisiert wird.
Wenn Promise verfügbar ist, wird request zu einer Promise-fähigen Bibliothek – und eine Verkettung then s wird möglich:
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 ;
} ) ; Manchmal müssen Sie Cookies von einer Anfrage behalten und sie mit der nächsten senden (z. B. wenn Sie sich mit der ersten Anfrage anmelden und später auf eine nur authentifizierte Ressource zugreifen möchten). Hierfür steht .request.agent() zur Verfügung:
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 ) ;
} ) ;
} ) ; Hinweis: Der von request.agent(app) gestartete Server wird nach den Tests nicht automatisch geschlossen. Sie sollten agent.close() nach Ihren Tests aufrufen, um sicherzustellen, dass Ihr Programm beendet wird.
Das Chai-HTTP-Modul stellt eine Reihe von Zusicherungen für die expect und should -Schnittstellen bereit.
Stellen Sie sicher, dass eine Antwort den Status „Geliefert“ hat.
expect ( res ) . to . have . status ( 200 ) ; Stellen Sie sicher, dass ein Response oder Request einen Header hat. Wenn ein Wert angegeben wird, wird Wertgleichheit geltend gemacht. Sie können zur Überprüfung auch einen regulären Ausdruck übergeben.
Hinweis: Bei der Ausführung in einem Webbrowser erlaubt die Same-Origin-Richtlinie nur, dass Chai HTTP bestimmte Header liest, was dazu führen kann, dass Behauptungen fehlschlagen.
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 / ) ; Stellen Sie sicher, dass ein Response oder Request Header hat.
Hinweis: Bei der Ausführung in einem Webbrowser erlaubt die Same-Origin-Richtlinie nur, dass Chai HTTP bestimmte Header liest, was dazu führen kann, dass Behauptungen fehlschlagen.
expect ( req ) . to . have . headers ;Stellen Sie sicher, dass eine Zeichenfolge eine gültige IP-Adresse darstellt.
expect ( '127.0.0.1' ) . to . be . an . ip ;
expect ( '2001:0db8:85a3:0000:0000:8a2e:0370:7334' ) . to . be . an . ip ; Stellen Sie sicher, dass ein Response oder Request einen bestimmten Inhaltstyp hat.
expect ( req ) . to . be . json ;
expect ( req ) . to . be . html ;
expect ( req ) . to . be . text ; Stellen Sie sicher, dass ein Response oder Request einen bestimmten Zeichensatz hat.
expect ( req ) . to . have . charset ( 'utf-8' ) ; Stellen Sie sicher, dass ein Response einen Umleitungsstatuscode hat.
expect ( res ) . to . redirect ;
expect ( res ) . to . not . redirect ; Stellen Sie sicher, dass ein Response an den angegebenen Speicherort umleitet.
expect ( res ) . to . redirectTo ( 'http://example.com' ) ;
expect ( res ) . to . redirectTo ( / ^/search/results?orderBy=desc$ / ) ; Stellen Sie sicher, dass ein Request -Objekt über einen Abfragezeichenfolgenparameter mit einem bestimmten Schlüssel verfügt, der (optional) dem Wert entspricht
expect ( req ) . to . have . param ( 'orderby' ) ;
expect ( req ) . to . have . param ( 'orderby' , 'date' ) ;
expect ( req ) . to . not . have . param ( 'limit' ) ; Stellen Sie sicher, dass ein Request oder Response Objekt einen Cookie-Header mit einem bestimmten Schlüssel hat, der (optional) dem Wert entspricht
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 wird mit semantic-release unter Verwendung der Plugins veröffentlicht:
commit-analyzer um die nächste Version aus Commit-Nachrichten zu ermitteln.release-notes-generator zum Zusammenfassen der Veröffentlichung inchangelog um die Datei CHANGELOG.md zu aktualisieren.github um eine GitHub-Version zu veröffentlichen.git zum Festschreiben von Release-Assets.npm zur Veröffentlichung auf npm. (Die MIT-Lizenz)
Copyright (c) Jake Luer [email protected]
Hiermit wird jeder Person, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die „Software“) erhält, kostenlos die Erlaubnis erteilt, mit der Software ohne Einschränkung zu handeln, einschließlich und ohne Einschränkung der Rechte zur Nutzung, zum Kopieren, Ändern und Zusammenführen , Kopien der Software zu veröffentlichen, zu verteilen, unterzulizenzieren und/oder zu verkaufen und Personen, denen die Software zur Verfügung gestellt wird, dies zu gestatten, vorbehaltlich der folgenden Bedingungen:
Der obige Urheberrechtshinweis und dieser Genehmigungshinweis müssen in allen Kopien oder wesentlichen Teilen der Software enthalten sein.
DIE SOFTWARE WIRD „WIE BESEHEN“ ZUR VERFÜGUNG GESTELLT, OHNE JEGLICHE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GEWÄHRLEISTUNG, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GEWÄHRLEISTUNG DER MARKTGÄNGIGKEIT, EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND NICHTVERLETZUNG. IN KEINEM FALL SIND DIE AUTOREN ODER URHEBERRECHTSINHABER HAFTBAR FÜR JEGLICHE ANSPRÜCHE, SCHÄDEN ODER ANDERE HAFTUNG, WEDER AUS EINER VERTRAGLICHEN HANDLUNG, AUS HANDLUNG ODER ANDERWEITIG, DIE SICH AUS, AUS ODER IN ZUSAMMENHANG MIT DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN HANDELN IN DER SOFTWARE ERGEBEN SOFTWARE.
