node mocks http

Logotipo

Os objetos 'http' simulados para testar funções Express, Next.js e KOA, mas podem ser usados para testar os aplicativos Node.js Web Server que possuem código que requer modelos dos objetos de request e response .

Instalação

Este projeto está disponível como um pacote NPM.

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

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

Depois de instalar o pacote, inclua o seguinte em seus arquivos de teste:

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

Uso

Suponha que você tenha a seguinte rota expressa:

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

E você criou uma função para lidar com a chamada dessa rota:

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

Você pode testar facilmente a função routeHandler com algum código como este usando a estrutura de teste de sua escolha:

 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 ( ) ;
} ;

Tipas de texto datilografados

As tíqueas para o TypeScript são agrupadas com este projeto. Em particular, os métodos .createRequest() , .createResponse() e .createMocks() são digitados e são genéricos. A menos que especificado explicitamente, eles retornarão um objeto de solicitação/resposta baseado em expresso:

 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 ( ) ;
} ) ;

O parâmetro de tipo esperado na solicitação e resposta simulada espera qualquer tipo que estenda a interface NodeJS http.IncomingRequest ou a classe de Request da API busca. Isso significa que você também pode zombar de solicitações provenientes de outras estruturas. Um exemplo para a solicitação NextJS ficará assim:

 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.
} ) ;

Também é possível zombar de solicitações do NextJS Novo apropriado:

 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)

Onde opções é um hash de objeto com qualquer um dos seguintes valores:

opção	descrição	valor padrão
`method`	Solicite o método HTTP	'PEGAR'
`url`	solicitar url	''
`originalUrl`	Solicite URL original	`url`
`baseUrl`	Solicitar URL base	`url`
`path`	Caminho de solicitação	''
`params`	Hash de objeto com params	{}
`session`	hash de objeto com valores de sessão	`undefined`
`cookies`	Hash de objeto com cookies de solicitação	{}
`socket`	Hash de objeto com soquete de solicitação	{}
`signedCookies`	Hash de objeto com cookies assinados	`undefined`
`headers`	Hash de objeto com cabeçalhos de solicitação	{}
`body`	Hash de objeto com corpo	{}
`query`	hash de objeto com valores de consulta	{}
`files`	hash de objeto com valores	{}

O objeto retornado dessa função também suporta as funções de solicitação expressa ( .accepts() , .is() , .get() , .range() , etc.). Por favor, envie um PR para quaisquer funções ausentes.

.Cremesponse ()

 httpMocks . createResponse ( options ) ;

Onde opções é um hash de objeto com qualquer um dos seguintes valores:

opção	descrição	valor padrão
`locals`	objeto que contém `response` variáveis locais	`{}`
`eventEmitter`	Emissor de eventos usado pelo objeto `response`	`mockEventEmitter`
`writableStream`	fluxo gravável usado por objeto `response`	`mockWritableStream`
`req`	Solicitar objeto que está sendo respondido	nulo

NOTA: O emissor de eventos simulado pronta para a caixa incluído no node-mocks-http não é um emissor de eventos funcionais e, como tal, não emite eventos. Se você deseja testar seus manipuladores de eventos, precisará trazer seu próprio emissor de eventos.

Aqui está um exemplo:

 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 ( ) ;
    } ) ;
  } ) ;
// ...

Este é um exemplo para enviar o corpo de solicitação e acionar seus eventos 'dados' e 'end':

 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 ) ;

Murar createRequest e createResponse . Passa as opções fornecidas objeto para cada construtor. Retorna um objeto com propriedades req e res .

Decisões de design

Queríamos algumas zombarias simples sem uma grande estrutura.

Também queríamos que as zombares agissem como a estrutura original sendo ridicularizada, mas permitisse a definição de valores antes de chamar e inspecionar valores após a chamada.

Para desenvolvedores

Estamos procurando mais voluntários para agregar valor a este projeto, incluindo a criação de mais objetos do módulo HTTP.

Este projeto não aborda todos os recursos que devem ser ridicularizados, mas é um bom começo. Sinta -se à vontade para enviar solicitações de tração e um membro da equipe será oportuno para mesclá -las.

Se você deseja contribuir, leia nossas diretrizes contribuintes.

Notas de liberação

A maioria das liberações corrige bugs com nossas manchas ou adiciona recursos semelhantes aos objetos reais Request e Response oferecidos pelo Node.js e estendidos pelo Express.

Veja o histórico de lançamento para obter detalhes.