node mocks http Download - node mocks http Source Code Download

Logo

Mock 'http' Objekte zum Testen von Express-, Next.js- und KOA -Routing -Funktionen, können jedoch zum Testen von Node.JS -Webserveranwendungen verwendet werden, die Code haben, für die Mockups der request und response erforderlich sind.

Installation

Dieses Projekt ist als NPM -Paket erhältlich.

$ npm install node-mocks-http --save-dev
$ npm install @types/node @types/express --save-dev # when using TypeScript

oder

$ yarn add node-mocks-http --dev
$ yarn add @types/node @types/express --dev # when using TypeScript

Nach der Installation des Pakets finden Sie in Ihren Testdateien Folgendes:

 const httpMocks = require ( 'node-mocks-http' ) ;

Verwendung

Angenommen, Sie haben die folgende Expressroute:

 app . get ( '/user/:id' , routeHandler ) ;

Und Sie haben eine Funktion erstellt, um den Anruf dieser Route zu verarbeiten:

 const routeHandler = function ( request , response ) { ... } ;

Sie können die routeHandler -Funktion mit einem solchen Code einfach mit dem Test -Framework Ihrer Wahl testen:

 exports [ 'routeHandler - Simple testing' ] = function ( test ) {
    const request = httpMocks . createRequest ( {
        method : 'GET' ,
        url : '/user/42' ,
        params : {
            id : 42
        }
    } ) ;

    const response = httpMocks . createResponse ( ) ;

    routeHandler ( request , response ) ;

    const data = response . _getJSONData ( ) ; // short-hand for JSON.parse( response._getData() );
    test . equal ( 'Bob Dog' , data . name ) ;
    test . equal ( 42 , data . age ) ;
    test . equal ( '[email protected]' , data . email ) ;

    test . equal ( 200 , response . statusCode ) ;
    test . ok ( response . _isEndCalled ( ) ) ;
    test . ok ( response . _isJSON ( ) ) ;
    test . ok ( response . _isUTF8 ( ) ) ;

    test . done ( ) ;
} ;

Typierungen Typen

Die Typierungen für Typscript sind mit diesem Projekt gebündelt. Insbesondere die Methoden .createRequest() , .createResponse() und .createMocks() werden tippt und generisch. Sofern nicht ausdrücklich angegeben, werden sie ein ausdrückliches Anforderungs-/Antwortobjekt zurückgeben:

 it ( 'should handle expressjs requests' , ( ) => {
    const mockExpressRequest = httpMocks . createRequest ( {
        method : 'GET' ,
        url : '/user/42' ,
        params : {
            id : 42
        }
    } ) ;
    const mockExpressResponse = httpMocks . createResponse ( ) ;

    routeHandler ( request , response ) ;

    const data = response . _getJSONData ( ) ;
    test . equal ( 'Bob Dog' , data . name ) ;
    test . equal ( 42 , data . age ) ;
    test . equal ( '[email protected]' , data . email ) ;

    test . equal ( 200 , response . statusCode ) ;
    test . ok ( response . _isEndCalled ( ) ) ;
    test . ok ( response . _isJSON ( ) ) ;
    test . ok ( response . _isUTF8 ( ) ) ;

    test . done ( ) ;
} ) ;

Der erwartete Typparameter in der Mock -Anforderung und -Ronaktion erwartet jeden Typ, der die NodeJS http.IncomingRequest -Schnittstelle oder die API Request abrufen. Dies bedeutet, dass Sie auch Anfragen aus anderen Frameworks verspotten können. Ein Beispiel für die NextJS -Anfrage sieht folgendermaßen aus:

 it ( 'should handle nextjs requests' , ( ) => {
    const mockExpressRequest = httpMocks . createRequest < NextApiRequest > ( {
        method : 'GET' ,
        url : '/user/42' ,
        params : {
            id : 42
        }
    } ) ;
    const mockExpressResponse = httpMocks . createResponse < NextApiResponse > ( ) ;

    // ... the rest of the test as above.
} ) ;

Es ist auch möglich, Anfragen aus dem NextJS New Cuberuter zu verspotten:

 it ( 'should handle nextjs app reouter requests' , ( ) => {
    const mockExpressRequest = httpMocks . createRequest < NextRequest > ( {
        method : 'GET' ,
        url : '/user/42' ,
        params : {
            id : 42
        }
    } ) ;
    const mockExpressResponse = httpMocks . createResponse < NextResponse > ( ) ;

    // ... the rest of the test as above.
} ) ;

API

.CreateRequest ()

 httpMocks.createRequest(options)

Wo Optionen ein Objekt -Hash mit einer der folgenden Werte sind:

Option	Beschreibung	Standardwert
`method`	Anfrage HTTP -Methode	'ERHALTEN'
`url`	URL anfordern	'' '
`originalUrl`	Fordern Sie die ursprüngliche URL an	`url`
`baseUrl`	Basis -URL anfordern	`url`
`path`	Pfad anfordern	'' '
`params`	Objekt Hash mit Params	{}
`session`	Objekt -Hash mit Sitzungswerten	`undefined`
`cookies`	Objekt Hash mit Anforderungs Cookies	{}
`socket`	Objekt Hash mit Anforderungsstecket	{}
`signedCookies`	Objekt Hash mit signierten Keksen	`undefined`
`headers`	Objekt Hash mit Anforderungsüberschriften	{}
`body`	Objekt Hash mit dem Körper	{}
`query`	Objekt -Hash mit Abfragestaten	{}
`files`	Objekt Hash mit Werten	{}

Das von dieser Funktion zurückgegebene Objekt unterstützt auch die Express -Anforderungsfunktionen ( .accepts() , .is() , .get() , .range() usw.). Bitte senden Sie eine PR für fehlende Funktionen.

.Creeateresponse ()

 httpMocks . createResponse ( options ) ;

Wo Optionen ein Objekt -Hash mit einer der folgenden Werte sind:

Option	Beschreibung	Standardwert
`locals`	Objekt, das `response` lokale Variablen enthält	`{}`
`eventEmitter`	Ereignisemitter, der vom `response` verwendet wird	`mockEventEmitter`
`writableStream`	Beschreibbarer Stream, der vom `response` verwendet wird	`mockWritableStream`
`req`	Anfordern, dass das Objekt beantwortet wird	NULL

HINWEIS: Der mit node-mocks-http enthaltene Mock-Ereignisemitter ist kein funktionaler Ereignisemitter und emittiert als solche keine Ereignisse. Wenn Sie Ihre Event -Handler testen möchten, müssen Sie Ihren eigenen Event -Emitter mitbringen.

Hier ist ein Beispiel:

 const httpMocks = require ( 'node-mocks-http' ) ;
const res = httpMocks . createResponse ( {
  eventEmitter : require ( 'events' ) . EventEmitter
} ) ;

// ...
  it ( 'should do something' , function ( done ) {
    res . on ( 'end' , function ( ) {
      assert . equal ( ... ) ;
      done ( ) ;
    } ) ;
  } ) ;
// ...

Dies ist ein Beispiel, um Anforderungsorganisationen zu senden und die Ereignisse "Daten" und "Ende" auszulösen:

 const httpMocks = require ( 'node-mocks-http' ) ;
const req = httpMocks . createRequest ( ) ;
const res = httpMocks . createResponse ( {
    eventEmitter : require ( 'events' ) . EventEmitter
} ) ;

// ...
it ( 'should do something' , function ( done ) {
    res . on ( 'end' , function ( ) {
        expect ( response . _getData ( ) ) . to . equal ( 'data sent in request' ) ;
        done ( ) ;
    } ) ;

    route ( req , res ) ;

    req . send ( 'data sent in request' ) ;
} ) ;

function route ( req , res ) {
    let data = [ ] ;
    req . on ( 'data' , ( chunk ) => {
        data . push ( chunk ) ;
    } ) ;
    req . on ( 'end' , ( ) => {
        data = Buffer . concat ( data ) ;
        res . write ( data ) ;
        res . end ( ) ;
    } ) ;
}
// ...

.CreateMocks ()

 httpMocks . createMocks ( reqOptions , resOptions ) ;

Zusammenschlüsselt createRequest und createResponse . Übergibt an jeden Konstruktor das angegebene Optionsobjekt. Gibt ein Objekt mit Eigenschaften req und res zurück.

Entwurfsentscheidungen

Wir wollten einige einfache Mocks ohne einen großen Gerüst.

Wir wollten auch, dass die Mocks sich so verhalten, als würde das ursprüngliche Rahmen verspottet, aber die Einstellung von Werten ermöglichen, bevor sie nach dem Aufrufen der Werte angerufen und inspiziert werden.

Für Entwickler

Wir suchen nach mehr Freiwilligen, um dieses Projekt einen Mehrwert zu bringen, einschließlich der Erstellung von mehr Objekten aus dem HTTP -Modul.

Dieses Projekt befasst sich nicht mit allen Funktionen, die verspottet werden müssen, aber es ist ein guter Anfang. Fühlen Sie sich frei, Pull -Anfragen zu senden, und ein Mitglied des Teams wird sie rechtzeitig zusammenführen.

Wenn Sie einen Beitrag leisten möchten, lesen Sie bitte unsere beitragenden Richtlinien.

Versionshinweise

Die meisten Releases beheben Fehler mit unseren Mocks oder fügen Funktionen hinzu, die den von Node.js angebotenen tatsächlichen Request und Response ähneln und von Express erweitert werden.

Einzelheiten finden Sie in der Veröffentlichungsgeschichte.