New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

node-mocks-http

Package Overview
Dependencies
Maintainers
2
Versions
65
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

node-mocks-http - npm Package Compare versions

Comparing version

1.0.1
to
1.0.3

.jshintrc

68

examples/express-route.js

@@ -0,1 +1,3 @@

'use strict';
var httpMocks = require('../lib/http-mock');

@@ -9,17 +11,17 @@

var aroute = function( request, response ) {
var aroute = function (request, response) {
var id = request.params.id;
console.log("We have a '%s' request for %s (ID: %d)",
request.method, request.url, id);
var id = request.params.id;
console.log('We have a \'%s\' request for %s (ID: %d)',
request.method, request.url, id);
var body = {
name: 'Bob Dog',
age: 42,
email: 'bob@dog.com'
};
response.setHeader('Content-Type', 'application/json');
response.statusCode = 200;
response.send( JSON.stringify(body), 'utf8' );
response.end();
var body = {
name: 'Bob Dog',
age: 42,
email: 'bob@dog.com'
};
response.setHeader('Content-Type', 'application/json');
response.statusCode = 200;
response.send(JSON.stringify(body), 'utf8');
response.end();
};

@@ -30,22 +32,24 @@

exports['aroute - Simple testing'] = function(test) {
var request = httpMocks.createRequest({
method: 'GET',
url: '/user/42',
params: { id: 42 }
});
var response = httpMocks.createResponse();
aroute(request, response);
var data = JSON.parse( response._getData() );
test.equal("Bob Dog", data.name);
test.equal(42, data.age);
test.equal("bob@dog.com", data.email);
exports['aroute - Simple testing'] = function (test) {
var request = httpMocks.createRequest({
method: 'GET',
url: '/user/42',
params: {
id: 42
}
});
var response = httpMocks.createResponse();
test.equal(200, response.statusCode );
test.ok( response._isEndCalled());
test.ok( response._isJSON());
test.ok( response._isUTF8());
test.done();
aroute(request, response);
var data = JSON.parse(response._getData());
test.equal('Bob Dog', data.name);
test.equal(42, data.age);
test.equal('bob@dog.com', data.email);
test.equal(200, response.statusCode);
test.ok(response._isEndCalled());
test.ok(response._isJSON());
test.ok(response._isUTF8());
test.done();
};

22

lib/mockEventEmitter.js
/*
* http://nodejs.org/api/events.html
*/
*/
function EventEmitter(){}
function EventEmitter() {}
EventEmitter.prototype.addListener = function(event, listener){}
EventEmitter.prototype.on = function(event, listener){}
EventEmitter.prototype.once = function(event, listener){}
EventEmitter.prototype.removeListener = function(event, listener){}
EventEmitter.prototype.removeAllListeners = function(event){}
EventEmitter.prototype.addListener = function (event, listener) {};
EventEmitter.prototype.on = function (event, listener) {};
EventEmitter.prototype.once = function (event, listener) {};
EventEmitter.prototype.removeListener = function (event, listener) {};
EventEmitter.prototype.removeAllListeners = function (event) {};
// EventEmitter.prototype.removeAllListeners = function([event])
EventEmitter.prototype.setMaxListeners = function(n){}
EventEmitter.prototype.listeners = function(event){}
EventEmitter.prototype.emit = function(event){}
EventEmitter.prototype.setMaxListeners = function (n) {};
EventEmitter.prototype.listeners = function (event) {};
EventEmitter.prototype.emit = function (event) {};
// EventEmitter.prototype.emit = function(event, [arg1], [arg2], [...]){}
module.exports = EventEmitter;
module.exports = EventEmitter;

292

lib/mockRequest.js

@@ -0,8 +1,10 @@

'use strict';
/**
* File: mockRequest
*
*
* This file implements node.js's implementation of a 'request' object.
* This is actually closer to what Express offers the user, in that the
* body is really a parsed object of values.
*
*
* @author Howard Abrams <howard.abrams@gmail.com>

@@ -15,3 +17,3 @@ */

* Creates a new mock 'request' instance. All values are reset to the
* defaults.
* defaults.
*

@@ -27,154 +29,154 @@ * Parameters:

* params - The parameters, see <mockRequest._setParam>
* body - The body values, , see <mockRequest._setBody>
* body - The body values, , see <mockRequest._setBody>
*/
exports.createRequest = function(options) {
if (!options) {
options = {};
}
exports.createRequest = function (options) {
if (!options) {
options = {};
}
return {
method : (options.method) ? options.method : 'GET',
url : (options.url ) ? options.url : '',
params : (options.params) ? options.params : {},
session: (options.session) ? options.session : {},
cookies: (options.cookies) ? options.cookies : {},
headers: (options.headers) ? options.headers: {},
body : (options.body ) ? options.body : {},
query : (options.query ) ? options.query : {},
files : (options.files ) ? options.files : {},
return {
method: (options.method) ? options.method : 'GET',
url: (options.url) ? options.url : '',
params: (options.params) ? options.params : {},
session: (options.session) ? options.session : {},
cookies: (options.cookies) ? options.cookies : {},
headers: (options.headers) ? options.headers : {},
body: (options.body) ? options.body : {},
query: (options.query) ? options.query : {},
files: (options.files) ? options.files : {},
/**
* Function: _setParameter
*
* Set parameters that the client can then get using the 'params'
* key.
*
* Parameters:
*
* key - The key. For instance, 'bob' would be accessed: request.params.bob
* value - The value to return when accessed.
*/
/**
* Function: _setParameter
*
* Set parameters that the client can then get using the 'params'
* key.
*
* Parameters:
*
* key - The key. For instance, 'bob' would be accessed: request.params.bob
* value - The value to return when accessed.
*/
_setParameter: function( key, value ) {
this.params[key] = value;
},
_setParameter: function (key, value) {
this.params[key] = value;
},
/**
* Sets a variable that is stored in the session.
*
* @param variable The variable to store in the session
* @param value The value associated with the variable
*/
_setSessionVariable: function( variable, value ) {
this.session[variable] = value;
},
/**
* Sets a variable that is stored in the session.
*
* @param variable The variable to store in the session
* @param value The value associated with the variable
*/
_setSessionVariable: function (variable, value) {
this.session[variable] = value;
},
/**
* Sets a variable that is stored in the cookies.
*
* @param variable The variable to store in the cookies
* @param value The value associated with the variable
*/
_setCookiesVariable: function( variable, value ) {
this.cookies[variable] = value;
},
/**
* Sets a variable that is stored in the cookies.
*
* @param variable The variable to store in the cookies
* @param value The value associated with the variable
*/
_setCookiesVariable: function (variable, value) {
this.cookies[variable] = value;
},
/**
* Sets a variable that is stored in the headers.
*
* @param variable The variable to store in the headers
* @param value The value associated with the variable
*/
_setHeadersVariable: function( variable, value ) {
this.headers[variable] = value;
},
/**
* Sets a variable that is stored in the headers.
*
* @param variable The variable to store in the headers
* @param value The value associated with the variable
*/
_setHeadersVariable: function (variable, value) {
this.headers[variable] = value;
},
/**
* Sets a variable that is stored in the files.
*
* @param variable The variable to store in the files
* @param value The value associated with the variable
*/
_setFilesVariable: function( variable, value ) {
this.files[variable] = value;
},
/**
* Sets a variable that is stored in the files.
*
* @param variable The variable to store in the files
* @param value The value associated with the variable
*/
_setFilesVariable: function (variable, value) {
this.files[variable] = value;
},
/**
* Function: _setMethod
*
* Sets the HTTP method that the client gets when the called the 'method'
* property. This defaults to 'GET' if it is not set.
*
* Parameters:
*
* method - The HTTP method, e.g. GET, POST, PUT, DELETE, etc.
*
* Note: We don't validate the string. We just return it.
*/
_setMethod: function( method ) {
this.method = method;
},
/**
* Function: _setURL
*
* Sets the URL value that the client gets when the called the 'url'
* property.
*
* Parameters:
*
* url - The request path, e.g. /my-route/452
*
* Note: We don't validate the string. We just return it. Typically, these
* do not include hostname, port or that part of the URL.
*/
_setURL: function( url ) {
this.url = url;
},
/**
* Function: _setBody
*
* Sets the body that the client gets when the called the 'body'
* parameter. This defaults to 'GET' if it is not set.
*
* Parameters:
*
* body - An object representing the body.
*
* If you expect the 'body' to come from a form, this typically means that
* it would be a flat object of properties and values, as in:
*
* > { name: 'Howard Abrams',
* > age: 522
* > }
*
* If the client is expecting a JSON object through a REST interface, then
* this object could be anything.
*/
/**
* Function: _setMethod
*
* Sets the HTTP method that the client gets when the called the 'method'
* property. This defaults to 'GET' if it is not set.
*
* Parameters:
*
* method - The HTTP method, e.g. GET, POST, PUT, DELETE, etc.
*
* Note: We don't validate the string. We just return it.
*/
_setBody: function( body ) {
this.body = body;
},
/**
* Function: _addBody
*
* Adds another body parameter the client gets when calling the 'body'
* parameter with another property value, e.g. the name of a form element
* that was passed in.
*
* Parameters:
*
* key - The key. For instance, 'bob' would be accessed: request.params.bob
* value - The value to return when accessed.
*/
_addBody: function( key, value ) {
this.body[key] = value;
}
};
};
_setMethod: function (method) {
this.method = method;
},
/**
* Function: _setURL
*
* Sets the URL value that the client gets when the called the 'url'
* property.
*
* Parameters:
*
* url - The request path, e.g. /my-route/452
*
* Note: We don't validate the string. We just return it. Typically, these
* do not include hostname, port or that part of the URL.
*/
_setURL: function (url) {
this.url = url;
},
/**
* Function: _setBody
*
* Sets the body that the client gets when the called the 'body'
* parameter. This defaults to 'GET' if it is not set.
*
* Parameters:
*
* body - An object representing the body.
*
* If you expect the 'body' to come from a form, this typically means that
* it would be a flat object of properties and values, as in:
*
* > { name: 'Howard Abrams',
* > age: 522
* > }
*
* If the client is expecting a JSON object through a REST interface, then
* this object could be anything.
*/
_setBody: function (body) {
this.body = body;
},
/**
* Function: _addBody
*
* Adds another body parameter the client gets when calling the 'body'
* parameter with another property value, e.g. the name of a form element
* that was passed in.
*
* Parameters:
*
* key - The key. For instance, 'bob' would be accessed: request.params.bob
* value - The value to return when accessed.
*/
_addBody: function (key, value) {
this.body[key] = value;
}
};
};

772

lib/mockResponse.js

@@ -0,1 +1,3 @@

'use strict';
/**

@@ -27,399 +29,461 @@ * File: mockResponse

var WritableStream = require('./mockWritableStream')
, EventEmitter = require('./mockEventEmitter');
var WritableStream = require('./mockWritableStream'),
EventEmitter = require('./mockEventEmitter');
exports.createResponse = function(options) {
if (!options) {
options = {};
}
exports.createResponse = function (options) {
if (!options) {
options = {};
}
var _endCalled = false;
var _data = "";
var _headers = {};
var _encoding = options.encoding;
var _endCalled = false;
var _data = '';
var _headers = {};
var _encoding = options.encoding;
var _redirectUrl = "";
var _renderView = "";
var _renderData = {};
var _redirectUrl = '';
var _renderView = '';
var _renderData = {};
var writableStream = new (options.writableStream || WritableStream)();
var eventEmitter = new (options.eventEmitter || EventEmitter)();
var writableStream = options.writableStream ?
new options.writableStream() :
new WritableStream();
var eventEmitter = options.eventEmitter ?
new options.eventEmitter() :
new EventEmitter();
return {
statusCode: -1,
return {
statusCode: -1,
cookies: {},
cookies: {},
cookie: function(name, value, options) {
this.cookies[name] = { value: value, options: options };
},
cookie: function (name, value, options) {
this.cookies[name] = {
value: value,
options: options
};
},
clearCookie: function(name) {
delete this.cookies[name]
},
clearCookie: function (name) {
delete this.cookies[name];
},
status: function(code) {
this.statusCode = code;
return this;
},
status: function (code) {
this.statusCode = code;
return this;
},
/**
* Function: writeHead
*
* The 'writeHead' function from node's HTTP API.
*
* Parameters:
*
* statusCode - A number to send as a the HTTP status
* headers - An object of properties that will be used for
* the HTTP headers.
*/
writeHead: function( statusCode, phrase, headers ) {
if (_endCalled) {
throw "The end() method has already been called.";
}
/**
* Function: writeHead
*
* The 'writeHead' function from node's HTTP API.
*
* Parameters:
*
* statusCode - A number to send as a the HTTP status
* headers - An object of properties that will be used for
* the HTTP headers.
*/
writeHead: function (statusCode, phrase, headers) {
if (_endCalled) {
throw 'The end() method has already been called.';
}
this.statusCode = statusCode;
this.statusCode = statusCode;
// Note: Not sure if the headers given in this function
// overwrite any headers specified earlier.
if (headers) {
_reasonPhrase = phrase;
_headers = headers;
}
else {
_headers = phrase;
}
},
// Note: Not sure if the headers given in this function
// overwrite any headers specified earlier.
if (headers) {
_headers = headers;
} else {
_headers = phrase;
}
},
/**
* The 'send' function from node's HTTP API that returns data
* to the client. Can be called multiple times.
*
* @param data The data to return. Must be a string.
*/
send: function( a, b, c ) {
switch (arguments.length) {
case 1:
_data += a;
break;
/**
* The 'send' function from node's HTTP API that returns data
* to the client. Can be called multiple times.
*
* @param data The data to return. Must be a string.
*/
send: function (a, b, c) {
var _self = this;
var _formatData = function(a) {
if (typeof a === 'object') {
if (a.statusCode) {
_self.statusCode = a.statusCode;
}
else if (a.httpCode) {
_self.statusCode = a.statusCode;
}
if (a.body) {
_data = a.body;
}
else {
_data = a;
}
} else {
_data += a;
}
};
case 2:
if (typeof a == 'number') {
this.statusCode = a;
_data += b;
}
else if (typeof b == 'number') {
_data += a;
this.statusCode = b;
console.warn("WARNING: Called 'send' with deprecated parameter order");
}
else {
_data += a;
_encoding = b;
}
break;
switch (arguments.length) {
case 1:
if (typeof a === 'number') {
this.statusCode = a;
} else {
_formatData(a);
}
break;
case 3:
_data += a;
_headers = b;
this.statusCode = c;
console.warn("WARNING: Called 'send' with deprecated three parameters");
break;
case 2:
if (typeof a === 'number') {
_formatData(b);
this.statusCode = a;
} else if (typeof b === 'number') {
_formatData(a);
this.statusCode = b;
console.warn('WARNING: Called send() with deprecated parameter order');
} else {
_formatData(a);
_encoding = b;
}
break;
default:
break;
}
},
case 3:
_formatData(a);
_headers = b;
this.statusCode = c;
console.warn('WARNING: Called send() with deprecated three parameters');
break;
default:
break;
}
/**
* Function: write
*
* This function has the same behavior as the 'send' function.
*
* Parameters:
*
* data - The data to return. Must be a string. Appended to
* previous calls to data.
* encoding - Optional encoding value.
*/
this.emit('send');
this.emit('end');
},
write: function( data, encoding ) {
_data += data;
if (encoding) {
_encoding = encoding;
}
},
/**
* The 'json' function from node's HTTP API that returns JSON data
* to the client. Should not be called multiple times.
*/
json: function (a, b) {
this.setHeader('Content-Type', 'application/json');
/**
* Function: end
*
* The 'end' function from node's HTTP API that finishes
* the connection request. This must be called.
*
* Parameters:
*
* data - Optional data to return. Must be a string. Appended
* to previous calls to <send>.
* encoding - Optional encoding value.
*/
end: function( data, encoding ) {
_endCalled = true;
if (data) {
_data += data;
}
if (encoding) {
_encoding = encoding;
}
},
switch (arguments.length) {
case 1:
if (typeof a === 'number') {
this.statusCode = a;
} else {
_data += JSON.stringify(a);
this.statusCode = 200;
}
break;
case 2:
this.statusCode = a;
_data += JSON.stringify(b);
/**
* Function: getHeader
*
* Returns a particular header by name.
*/
getHeader: function(name) {
return _headers[name];
},
break;
/**
* Function: setHeader
*
* Set a particular header by name.
*/
setHeader: function(name, value) {
return _headers[name] = value;
},
default:
break;
}
},
/**
* Function: removeHeader
*
* Removes an HTTP header by name.
*/
removeHeader: function(name) {
delete _headers[name];
},
/**
* Function: write
*
* This function has the same behavior as the 'send' function.
*
* Parameters:
*
* data - The data to return. Must be a string. Appended to
* previous calls to data.
* encoding - Optional encoding value.
*/
/**
* Function: setEncoding
*
* Sets the encoding for the data. Generally 'utf8'.
*
* Parameters:
*
* encoding - The string representing the encoding value.
*/
setEncoding: function(encoding) {
_encoding = encoding;
},
write: function (data, encoding) {
_data += data;
if (encoding) {
_encoding = encoding;
}
},
/**
* Function: redirect
*
* Redirect to a url with response code
*/
redirect: function(a, b) {
switch(arguments.length) {
case 1:
_redirectUrl = a;
break;
/**
* Function: end
*
* The 'end' function from node's HTTP API that finishes
* the connection request. This must be called.
*
* Parameters:
*
* data - Optional data to return. Must be a string. Appended
* to previous calls to <send>.
* encoding - Optional encoding value.
*/
end: function (data, encoding) {
_endCalled = true;
if (data) {
_data += data;
}
if (encoding) {
_encoding = encoding;
}
this.emit('end');
},
case 2:
if (typeof a == 'number') {
this.statusCode = a;
_redirectUrl = b;
}
break;
default:
break;
}
},
/**
* Function: getHeader
*
* Returns a particular header by name.
*/
getHeader: function (name) {
return _headers[name];
},
/**
* Function: render
*
* Render a view with a callback responding with the
* rendered string.
*/
render: function(a, b, c) {
_renderView = a;
switch(arguments.length) {
case 2:
break;
/**
* Function: setHeader
*
* Set a particular header by name.
*/
setHeader: function (name, value) {
_headers[name] = value;
return value;
},
case 3:
_renderData = b;
break;
/**
* Function: removeHeader
*
* Removes an HTTP header by name.
*/
removeHeader: function (name) {
delete _headers[name];
},
default:
break;
}
},
/**
* Function: setEncoding
*
* Sets the encoding for the data. Generally 'utf8'.
*
* Parameters:
*
* encoding - The string representing the encoding value.
*/
setEncoding: function (encoding) {
_encoding = encoding;
},
writable: function(){
return writableStream.writable.apply(this, arguments);
},
// end: function(){
// return writableStream.end.apply(this, arguments);
// },
destroy: function(){
return writableStream.destroy.apply(this, arguments);
},
destroySoon: function(){
return writableStream.destroySoon.apply(this, arguments);
},
addListener: function(event, listener){
return eventEmitter.addListener.apply(this, arguments);
},
on: function(event, listener){
return eventEmitter.on.apply(this, arguments);
},
once: function(event, listener){
return eventEmitter.once.apply(this, arguments);
},
removeListener: function(event, listener){
return eventEmitter.removeListener.apply(this, arguments);
},
removeAllListeners: function(event){
return eventEmitter.removeAllListeners.apply(this, arguments);
},
setMaxListeners: function(n){
return eventEmitter.setMaxListeners.apply(this, arguments)
},
listeners: function(event){
return eventEmitter.listeners.apply(this, arguments);
},
emit: function(event){
return eventEmitter.emit.apply(this, arguments);
},
//This mock object stores some state as well
//as some test-analysis functions:
/**
* Function: redirect
*
* Redirect to a url with response code
*/
redirect: function (a, b) {
switch (arguments.length) {
case 1:
_redirectUrl = a;
break;
/**
* Function: _isEndCalled
*
* Since the <end> function must be called, this function
* returns true if it has been called. False otherwise.
*/
_isEndCalled: function() {
return _endCalled;
},
case 2:
if (typeof a === 'number') {
this.statusCode = a;
_redirectUrl = b;
}
break;
default:
break;
}
},
/**
* Function: _getHeaders
*
* Returns all the headers that were set. This may be an
* empty object, but probably will have "Content-Type" set.
*/
_getHeaders: function() {
return _headers;
},
/**
* Function: render
*
* Render a view with a callback responding with the
* rendered string.
*/
render: function (a, b, c) {
_renderView = a;
switch (arguments.length) {
case 2:
break;
/**
* Function: _getData
*
* The data sent to the user.
*/
_getData: function() {
return _data;
},
case 3:
_renderData = b;
break;
/**
* Function: _getStatusCode
*
* The status code that was sent to the user.
*/
_getStatusCode: function() {
return this.statusCode;
},
default:
break;
}
/**
* Function: _isJSON
*
* Returns true if the data sent was defined as JSON.
* It doesn't validate the data that was sent.
*/
_isJSON: function() {
return (_headers["Content-Type"] == "application/json");
},
this.emit('render');
this.emit('end');
},
/**
* Function: _isUTF8
*
* If the encoding was set, and it was set to UTF-8, then
* this function return true. False otherwise.
*
* Returns:
*
* False if the encoding wasn't set and wasn't set to "utf8".
*/
_isUTF8: function() {
if ( !_encoding ) {
return false;
}
return ( _encoding === "utf8" );
},
writable: function () {
return writableStream.writable.apply(this, arguments);
},
// end: function(){
// return writableStream.end.apply(this, arguments);
// },
destroy: function () {
return writableStream.destroy.apply(this, arguments);
},
destroySoon: function () {
return writableStream.destroySoon.apply(this, arguments);
},
addListener: function (event, listener) {
return eventEmitter.addListener.apply(this, arguments);
},
on: function (event, listener) {
return eventEmitter.on.apply(this, arguments);
},
once: function (event, listener) {
return eventEmitter.once.apply(this, arguments);
},
removeListener: function (event, listener) {
return eventEmitter.removeListener.apply(this, arguments);
},
removeAllListeners: function (event) {
return eventEmitter.removeAllListeners.apply(this, arguments);
},
setMaxListeners: function (n) {
return eventEmitter.setMaxListeners.apply(this, arguments);
},
listeners: function (event) {
return eventEmitter.listeners.apply(this, arguments);
},
emit: function (event) {
return eventEmitter.emit.apply(this, arguments);
},
//This mock object stores some state as well
//as some test-analysis functions:
/**
* Function: _isDataLengthValid
*
* If the Content-Length header was set, this will only
* return true if the length is actually the length of the
* data that was set.
*
* Returns:
*
* True if the "Content-Length" header was not
* set. Otherwise, it compares it.
*/
_isDataLengthValid: function() {
if (_headers["Content-Length"]) {
return (_headers["Content-Length"] == _data.length);
}
return true;
},
/**
* Function: _isEndCalled
*
* Since the <end> function must be called, this function
* returns true if it has been called. False otherwise.
*/
_isEndCalled: function () {
return _endCalled;
},
/**
* Function: _getRedirectUrl
*
* Return redirect url of redirect method
*
* Returns:
*
* Redirect url
*/
_getRedirectUrl: function() {
return _redirectUrl;
},
/**
* Function: _getRenderView
*
* Return render view of render method
*
* Returns:
*
* render view
*/
_getRenderView: function() {
return _renderView;
},
/**
* Function: _getHeaders
*
* Returns all the headers that were set. This may be an
* empty object, but probably will have "Content-Type" set.
*/
_getHeaders: function () {
return _headers;
},
/**
* Function: _getRenderData
*
* Return render data of render method
*
* Returns:
*
* render data
*/
_getRenderData: function() {
return _renderData;
}
};
/**
* Function: _getData
*
* The data sent to the user.
*/
_getData: function () {
return _data;
},
/**
* Function: _getStatusCode
*
* The status code that was sent to the user.
*/
_getStatusCode: function () {
return this.statusCode;
},
/**
* Function: _isJSON
*
* Returns true if the data sent was defined as JSON.
* It doesn't validate the data that was sent.
*/
_isJSON: function () {
return (_headers['Content-Type'] === 'application/json');
},
/**
* Function: _isUTF8
*
* If the encoding was set, and it was set to UTF-8, then
* this function return true. False otherwise.
*
* Returns:
*
* False if the encoding wasn't set and wasn't set to "utf8".
*/
_isUTF8: function () {
if (!_encoding) {
return false;
}
return (_encoding === 'utf8');
},
/**
* Function: _isDataLengthValid
*
* If the Content-Length header was set, this will only
* return true if the length is actually the length of the
* data that was set.
*
* Returns:
*
* True if the "Content-Length" header was not
* set. Otherwise, it compares it.
*/
_isDataLengthValid: function () {
if (_headers['Content-Length']) {
return (_headers['Content-Length'].toString() === _data.length.toString());
}
return true;
},
/**
* Function: _getRedirectUrl
*
* Return redirect url of redirect method
*
* Returns:
*
* Redirect url
*/
_getRedirectUrl: function () {
return _redirectUrl;
},
/**
* Function: _getRenderView
*
* Return render view of render method
*
* Returns:
*
* render view
*/
_getRenderView: function () {
return _renderView;
},
/**
* Function: _getRenderData
*
* Return render data of render method
*
* Returns:
*
* render data
*/
_getRenderData: function () {
return _renderData;
}
};
};

14

lib/mockWritableStream.js
/*
* http://nodejs.org/api/stream.html#stream_writable_stream
*/
*/
function WritableStream(){}
function WritableStream() {}
WritableStream.prototype.writable = function(){}
WritableStream.prototype.writable = function () {};
// WritableStream.prototype.write = function(string, [encoding], [fd]){}
// WritableStream.prototype.write = function(buffer){}
WritableStream.prototype.end = function(){}
WritableStream.prototype.end = function () {};
// WritableStream.prototype.end = function(string, encoding){}
// WritableStream.prototype.end = function(buffer){}
WritableStream.prototype.destroy = function(){}
WritableStream.prototype.destroySoon = function(){}
WritableStream.prototype.destroy = function () {};
WritableStream.prototype.destroySoon = function () {};
module.exports = WritableStream;
module.exports = WritableStream;

9

package.json

@@ -5,3 +5,3 @@ {

"description": "Mock 'http' objects for testing Express routing functions",
"version": "1.0.1",
"version": "1.0.3",
"homepage": "http://www.github.com/howardabrams/node-mocks-http",

@@ -26,3 +26,10 @@ "keywords": [

"node": ">=0.6"
},
"devDependencies":{
"nodeunit":"",
"node-restify-errors":"git://github.com/m9dfukc/node-restify-errors.git"
},
"scripts":{
"test": "./run-tests"
}
}

38

README.md

@@ -65,2 +65,15 @@ node-mocks-http

For Developers
=========
Obviously this project doesn't address all features that must be
mocked, but it is a start. Feel free to send pull requests, and I
promise to be timely in merging them.
After making any changes, please verify your work:
* npm install -g jshint
* npm install
* ./run-tests
Release Notes

@@ -73,2 +86,27 @@ =============

v 1.0.3
-------
* Merged changes by [invernizzie](https://github.com/invernizzie):
to address [#11](https://github.com/howardabrams/node-mocks-http/pull/11)
* Merged changes by [ericchaves](https://github.com/ericchaves):
> I extended your library a little but so it could also handle
> some structured responses. By doing so res.send now evaluate the
> data passed and search for either a statusCode or httpCode to be
> used, and also for a body to send as _data.
>
> It still working as expected (at least tests passed) for regular
> HTTP responses.
>
> Although I did it with node-restify in mind, it should work well
> for all other libs.
v 1.0.2
-------
* Added a `.json()` method to the response. (Thanks, diachedelic)
* Cleaned up all source files so ./run-tests passes.
* Cleaned up jshint issues.
v 1.0.1

@@ -75,0 +113,0 @@ -------

397

test/test-mockResponse.js

@@ -8,170 +8,173 @@ /**

var httpMocks = require('../lib/http-mock');
var EventEmitter = require('events').EventEmitter;
exports['object - Simple verification'] = function( test ) {
var response = httpMocks.createResponse();
exports['object - Simple verification'] = function (test) {
var response = httpMocks.createResponse();
response.send("Hello", 'utf8');
response.send("World");
test.equal("HelloWorld", response._getData());
test.ok( response._isUTF8());
test.ok(! response._isEndCalled());
test.done();
response.send("Hello", 'utf8');
response.send("World");
test.equal("HelloWorld", response._getData());
test.ok(response._isUTF8());
test.ok(!response._isEndCalled());
test.done();
};
exports['object - Data Initialization'] = function( test ) {
var response = httpMocks.createResponse();
test.equal(-1, response.statusCode);
test.equal("", response._getData());
test.ok( ! response._isUTF8());
test.ok( ! response._isEndCalled());
test.done();
exports['object - Data Initialization'] = function (test) {
var response = httpMocks.createResponse();
test.equal(-1, response.statusCode);
test.equal("", response._getData());
test.ok(!response._isUTF8());
test.ok(!response._isEndCalled());
test.done();
};
exports['end - Simple Verification'] = function(test) {
var response = httpMocks.createResponse();
exports['end - Simple Verification'] = function (test) {
var response = httpMocks.createResponse();
response.send("Hello");
response.end("World");
response.send("Hello");
response.end("World");
test.equal("HelloWorld", response._getData());
test.equal("HelloWorld", response._getData());
test.ok(response._isEndCalled());
test.done();
test.ok(response._isEndCalled());
test.done();
};
exports['end - No Data Called'] = function(test) {
var response = httpMocks.createResponse();
exports['end - No Data Called'] = function (test) {
var response = httpMocks.createResponse();
response.end("Hello World");
response.end("Hello World");
test.equal("Hello World", response._getData());
test.equal("Hello World", response._getData());
test.ok(response._isEndCalled());
test.done();
test.ok(response._isEndCalled());
test.done();
};
exports['write - Simple verification'] = function( test ) {
var response = httpMocks.createResponse();
exports['write - Simple verification'] = function (test) {
var response = httpMocks.createResponse();
response.write("Hello", 'utf8');
response.end("World");
response.write("Hello", 'utf8');
response.end("World");
test.equal("HelloWorld", response._getData());
test.equal("HelloWorld", response._getData());
test.ok( response._isUTF8());
test.ok( response._isEndCalled());
test.done();
test.ok(response._isUTF8());
test.ok(response._isEndCalled());
test.done();
};
exports['setHeader - Simple verification'] = function(test) {
var response = httpMocks.createResponse();
exports['setHeader - Simple verification'] = function (test) {
var response = httpMocks.createResponse();
response.setHeader('foo', 'bar');
response.setHeader('bling', 'blang');
response.setHeader('foo', 'bar');
response.setHeader('bling', 'blang');
test.equal('bar', response.getHeader('foo'));
test.equal('blang', response.getHeader('bling'));
test.equal('bar', response.getHeader('foo'));
test.equal('blang', response.getHeader('bling'));
response.removeHeader('bling');
test.ok( !response.getHeader('bling'));
response.removeHeader('bling');
test.ok(!response.getHeader('bling'));
test.done();
test.done();
};
exports['setHeader - Can not call after end'] = function(test) {
var response = httpMocks.createResponse();
exports['setHeader - Can not call after end'] = function (test) {
var response = httpMocks.createResponse();
var body = 'hello world';
response.end(body);
var body = 'hello world';
response.end(body);
test.throws( function() {
response.setHead('Content-Length', body.length);
});
test.done();
test.throws(function () {
response.setHead('Content-Length', body.length);
});
test.done();
};
exports['writeHead - Simple verification'] = function(test) {
var response = httpMocks.createResponse();
exports['writeHead - Simple verification'] = function (test) {
var response = httpMocks.createResponse();
var body = 'hello world';
response.writeHead(200, {
'Content-Length': body.length,
'Content-Type': 'text/plain' });
response.end(body);
var body = 'hello world';
response.writeHead(200, {
'Content-Length': body.length,
'Content-Type': 'text/plain'
});
response.end(body);
test.equal(200, response._getStatusCode() );
test.equal(body, response._getData() );
test.ok(response._isDataLengthValid() );
test.ok(response._isEndCalled());
test.ok(! response._isJSON());
test.done();
test.equal(200, response._getStatusCode());
test.equal(body, response._getData());
test.ok(response._isDataLengthValid());
test.ok(response._isEndCalled());
test.ok(!response._isJSON());
test.done();
};
exports['writeHead - Can not call after end'] = function(test) {
var response = httpMocks.createResponse();
exports['writeHead - Can not call after end'] = function (test) {
var response = httpMocks.createResponse();
var body = 'hello world';
response.end(body);
var body = 'hello world';
response.end(body);
test.throws( function() {
response.writeHead(200, {
'Content-Length': body.length,
'Content-Type': 'text/plain' });
test.throws(function () {
response.writeHead(200, {
'Content-Length': body.length,
'Content-Type': 'text/plain'
});
test.done();
});
test.done();
};
exports['status - Set the status code'] = function(test) {
var response = httpMocks.createResponse();
response.status(401);
test.equal(401, response._getStatusCode());
test.done();
exports['status - Set the status code'] = function (test) {
var response = httpMocks.createResponse();
response.status(401);
test.equal(401, response._getStatusCode());
test.done();
};
exports['send - Status code at the beginning'] = function(test) {
var s = 123;
var t = 'This is a weird status code';
exports['send - Status code at the beginning'] = function (test) {
var s = 123;
var t = 'This is a weird status code';
var response = httpMocks.createResponse();
response.send(s, t);
var response = httpMocks.createResponse();
response.send(s, t);
test.equal(s, response._getStatusCode());
test.equal(t, response._getData());
test.done();
test.equal(s, response._getStatusCode());
test.equal(t, response._getData());
test.done();
};
exports['send - Status code at the end'] = function(test) {
var s = 543;
var t = 'This is a weird status code';
exports['send - Status code at the end'] = function (test) {
var s = 543;
var t = 'This is a weird status code';
var response = httpMocks.createResponse();
response.send(t, s);
var response = httpMocks.createResponse();
response.send(t, s);
test.equal(s, response._getStatusCode());
test.equal(t, response._getData());
test.done();
test.equal(s, response._getStatusCode());
test.equal(t, response._getData());
test.done();
};
exports['implement - WriteableStream'] = function(test){
var response = httpMocks.createResponse();
test.equal(typeof(response.writable), 'function');
test.equal(typeof(response.destroy), 'function');
test.equal(typeof(response.destroySoon), 'function');
test.done();
exports['implement - WriteableStream'] = function (test) {
var response = httpMocks.createResponse();
test.equal(typeof (response.writable), 'function');
test.equal(typeof (response.destroy), 'function');
test.equal(typeof (response.destroySoon), 'function');
test.done();
};
exports['implement - EventEmitter'] = function(test){
var response = httpMocks.createResponse();
test.equal(typeof(response.addListener), 'function');
test.equal(typeof(response.on), 'function');
test.equal(typeof(response.once), 'function');
test.equal(typeof(response.removeListener), 'function');
test.equal(typeof(response.removeAllListeners), 'function');
test.equal(typeof(response.setMaxListeners), 'function');
test.equal(typeof(response.listeners), 'function');
test.equal(typeof(response.emit), 'function');
test.done();
exports['implement - EventEmitter'] = function (test) {
var response = httpMocks.createResponse();
test.equal(typeof (response.addListener), 'function');
test.equal(typeof (response.on), 'function');
test.equal(typeof (response.once), 'function');
test.equal(typeof (response.removeListener), 'function');
test.equal(typeof (response.removeAllListeners), 'function');
test.equal(typeof (response.setMaxListeners), 'function');
test.equal(typeof (response.listeners), 'function');
test.equal(typeof (response.emit), 'function');
test.done();
};
exports['cookies - Cookies creation'] = function(test) {
exports['cookies - Cookies creation'] = function (test) {
var response = httpMocks.createResponse();

@@ -182,12 +185,23 @@ test.deepEqual(response.cookies, {});

exports['cookies - Cookies assignment'] = function(test) {
exports['cookies - Cookies assignment'] = function (test) {
var response = httpMocks.createResponse();
response.cookie("egg", "chicken", { maxAge: 1000 });
test.deepEqual(response.cookies, {egg: {value: 'chicken', options: { maxAge: 1000 }}});
response.cookie("egg", "chicken", {
maxAge: 1000
});
test.deepEqual(response.cookies, {
egg: {
value: 'chicken',
options: {
maxAge: 1000
}
}
});
test.done();
};
exports['cookies - Cookie deletion'] = function(test) {
exports['cookies - Cookie deletion'] = function (test) {
var response = httpMocks.createResponse();
response.cookie("egg", "chicken", { maxAge: 1000 });
response.cookie("egg", "chicken", {
maxAge: 1000
});
response.clearCookie("egg");

@@ -198,38 +212,133 @@ test.deepEqual(response.cookies, {});

exports['redirect - Redirect to a url with response code'] = function(test) {
var response = httpMocks.createResponse();
var url = '/index';
var responseCode = 200;
response.redirect(responseCode, url);
test.equal(response._getRedirectUrl(), url);
test.equal(response._getStatusCode(), responseCode);
exports['redirect - Redirect to a url with response code'] = function (test) {
var response = httpMocks.createResponse();
var url = '/index';
var responseCode = 200;
response.redirect(responseCode, url);
test.equal(response._getRedirectUrl(), url);
test.equal(response._getStatusCode(), responseCode);
test.done();
};
exports['redirect - Redirect to a url without response code'] = function (test) {
var response = httpMocks.createResponse();
var url = '/index';
response.redirect(url);
test.equal(response._getRedirectUrl(), url);
test.done();
};
exports['render - Render to a view with data'] = function (test) {
var response = httpMocks.createResponse();
var view = 'index';
var data = {
'name': 'bob'
};
var callback = function () {};
response.render(view, data, callback);
test.equal(response._getRenderView(), view);
test.deepEqual(response._getRenderData(), data);
test.done();
};
exports['render - Render to a view without data'] = function (test) {
var response = httpMocks.createResponse();
var view = 'index';
var callback = function () {};
response.render(view, callback);
test.equal(response._getRenderView(), view);
test.done();
};
exports['json - Without status code'] = function (test) {
var response = httpMocks.createResponse(),
data = {
hello: 'there'
};
response.json(data);
test.equal(response._isJSON(), true);
test.equal(response._getData(), JSON.stringify(data));
test.equal(response.statusCode, 200);
test.done();
};
exports['json - With status code'] = function (test) {
var response = httpMocks.createResponse(),
data = {
hello: 'there'
};
response.json(201, data);
test.equal(response._isJSON(), true);
test.equal(response._getData(), JSON.stringify(data));
test.equal(response.statusCode, 201);
test.done();
};
exports['events - end'] = function (test) {
var response = httpMocks.createResponse({
eventEmitter: EventEmitter
});
response.on('end', function () {
test.ok(response._isEndCalled());
test.done();
});
response.end();
};
exports['redirect - Redirect to a url without response code'] = function(test) {
var response = httpMocks.createResponse();
var url = '/index';
response.redirect(url);
test.equal(response._getRedirectUrl(), url);
exports['events - send'] = function (test) {
var response = httpMocks.createResponse({
eventEmitter: EventEmitter
});
response.on('send', function () {
test.equal(response.statusCode, 200);
test.done();
});
response.send(200);
};
exports['render - Render to a view with data'] = function(test) {
var response = httpMocks.createResponse();
var view = 'index';
var data = { 'name': 'bob' };
var callback = function() {};
response.render(view, data, callback);
exports['events - render'] = function (test) {
var response = httpMocks.createResponse({
eventEmitter: EventEmitter
});
var view = 'index';
var data = {
'name': 'bob'
};
var callback = function () {};
response.on('render', function () {
test.equal(response._getRenderView(), view);
test.deepEqual(response._getRenderData(), data);
test.done();
});
response.render(view, data, callback);
};
exports['render - Render to a view without data'] = function(test) {
var response = httpMocks.createResponse();
var view = 'index';
var callback = function() {};
response.render(view, callback);
test.equal(response._getRenderView(), view);
test.done();
exports['send - sending response objects a.k.a restifyError with statusCode'] = function(test) {
var errors = require('node-restify-errors')
var response = httpMocks.createResponse();
response.send(409, new errors.InvalidArgumentError("I just dont like you"));
test.equal(409, response._getStatusCode());
test.equal('InvalidArgument', response._getData().code);
test.equal('I just dont like you', response._getData().message);
test.done();
};
exports['send - sending response objects a.k.a restifyError without statusCode'] = function(test) {
var errors = require('node-restify-errors')
var response = httpMocks.createResponse();
response.send(new errors.InvalidArgumentError("I just dont like you"));
test.equal(409, response._getStatusCode());
test.equal('InvalidArgument', response._getData().code);
test.equal('I just dont like you', response._getData().message);
test.done();
};
run-tests

Sorry, the diff of this file is not supported yet