main

node_modules/node-rest-client/test/mocha.opts

@@ -0,0 +1,4 @@
+--require should
+--reporter spec test/specs/*.js
+--ui bdd
+--recursive

node_modules/node-rest-client/test/server/message.json

@@ -0,0 +1,34 @@
+{"catalog":{
+	"books":[{
+		   		"id":"bk101",
+		   		"author":"Gambardella, Matthew",
+		   		"title":"XML Developer's Guide",
+		   		"genre":"Computer",
+		   		"price":44.95,
+		   		"publish_date":"2000-10-10",
+		   		"description":"An in-depth look at creating applications with XML."
+		   		},
+				{
+		   		"id":"bk102",
+		   		"author":"Gambardella, Matthew",
+		   		"title":"JAVA Developer's Guide",
+		   		"genre":"Computer",
+		   		"price":188.95,
+		   		"publish_date":"2000-10-10",
+		   		"description":"An in-depth look at creating applications with JAVA."
+		   		},
+		   		{
+		   		"id":"bk103",
+		   		"author":"Gambardella, Matthew",
+		   		"title":"JSON Developer's Guide",
+		   		"genre":"Computer",
+		   		"price":422.95,
+		   		"publish_date":"2000-10-10",
+		   		"description":"An in-depth look at creating applications with JSON."
+		   		}
+   	]
+   	}
+ }  	
+
+
+  

node_modules/node-rest-client/test/server/message.xml

@@ -0,0 +1,43 @@
+<?xml version="1.0"?>
+<catalog>
+   <book id="bk101">
+      <author>Gambardella, Matthew</author>
+      <title>XML Developer's Guide</title>
+      <genre>Computer</genre>
+      <price>44.95</price>
+      <publish_date>2000-10-01</publish_date>
+      <description>An in-depth look at creating applications 
+      with XML.</description>
+   </book>
+   <book id="bk102">
+      <author>Ralls, Kim</author>
+      <title>Midnight Rain</title>
+      <genre>Fantasy</genre>
+      <price>5.95</price>
+      <publish_date>2000-12-16</publish_date>
+      <description>A former architect battles corporate zombies, 
+      an evil sorceress, and her own childhood to become queen 
+      of the world.</description>
+   </book>
+   <book id="bk103">
+      <author>Corets, Eva</author>
+      <title>Maeve Ascendant</title>
+      <genre>Fantasy</genre>
+      <price>5.95</price>
+      <publish_date>2000-11-17</publish_date>
+      <description>After the collapse of a nanotechnology 
+      society in England, the young survivors lay the 
+      foundation for a new society.</description>
+   </book>
+   <book id="bk104">
+      <author>Corets, Eva</author>
+      <title>Oberon's Legacy</title>
+      <genre>Fantasy</genre>
+      <price>5.95</price>
+      <publish_date>2001-03-10</publish_date>
+      <description>In post-apocalypse England, the mysterious 
+      agent known only as Oberon helps to create a new life 
+      for the inhabitants of London. Sequel to Maeve 
+      Ascendant.</description>
+   </book>
+ </catalog>  

node_modules/node-rest-client/test/server/mock-server.js

@@ -0,0 +1,210 @@
+var http = require('http'), fs = require('fs');
+
+var RouterOptions = {
+	"baseMessageDir" : "",
+	"JSONMessageFile" : './test/server/message.json',
+	"XMLMessageFile" : './test/server/message.xml'
+
+};
+
+var RouteManager = {
+	"findRoute" : function(req, res) {
+		var handler = null;
+		for ( var route in this.routes) {
+			if (req.url.startsWith(route)) {
+				handler = this.routes[route];
+			}
+
+		}
+		if (!handler)
+			throw "cannot find route " + req.url;
+		handler.call(this, req, res);
+	},
+	"routes" : {
+		"/json" : function(req, res) {
+			// this.sleep(5000);
+			var message = fs
+					.readFileSync(RouterOptions.JSONMessageFile, 'utf8');
+			res.writeHead(200, {
+				'Content-Type' : 'application/json',
+				'test-header'  : 'test'
+			});
+			res.write(message.toString());
+			res.end();
+		},
+		"/json/path" : function(req, res) {
+			// this.sleep(5000);
+			var message = {
+				"url" : req.url
+			};
+			res.writeHead(200, {
+				'Content-Type' : 'application/json',
+				'test-header'  :  req.url
+			});
+			res.write(JSON.stringify(message));
+			res.end();
+		},
+		"/xml" : function(req, res) {
+			var message = fs.readFileSync(RouterOptions.XMLMessageFile, 'utf8');
+			res.writeHead(200, {
+				'Content-Type' : 'application/xml'
+			});
+			res.write(message.toString());
+			res.end();
+		},
+		"/120/json?arg1=hello&arg2=world" : function(req, res) {
+			if (!req.headers["test-header"])
+				throw "no test-header found!!";
+			res.setHeader("test-response-header", req.headers["test-header"]);
+			this.routes["/json"](req, res);
+		},
+		"/json?post" : function(req, res) {
+			req.on('data', function(data) {
+				// console.log("[SERVER] data = ", data);
+				res.writeHead(200, {
+					'Content-Type' : 'application/json'
+				});
+				// res.writeHead(200, {'Content-Type': 'text/plain'});
+				res.write(data.toString());
+				res.end();
+			});
+
+		},
+		"/json/path/post" : function(req, res) {
+			req.on('data', function(data) {
+				var message = {
+					"url" : req.url
+				};
+				// console.log("[SERVER] data = ", data);
+				res.writeHead(200, {
+					'Content-Type' : 'application/json'
+				});
+				// res.writeHead(200, {'Content-Type': 'text/plain'});
+				message.postData = data.toString();
+				res.write(JSON.stringify(message));
+				res.end();
+			});
+
+		},
+		"/json/error" : function(req, res) {
+			// this.sleep(5000);
+			
+
+			res.writeHead(500, {'Content-Type': 'text/plain'});
+			res.end();
+			
+
+		},
+		"/xml/path/post" : function(req, res) {
+			req.on('data', function(data) {
+				// console.log("[SERVER] data = ", data);
+				res.writeHead(200, {
+					'Content-Type' : 'application/xml'
+				});
+				// res.writeHead(200, {'Content-Type': 'text/plain'});				
+				res.write(data.toString());
+				res.end();
+			});
+
+		},
+		"/json/empty" : function(req, res) {
+			res.writeHead(200, {
+				'Content-Type' : 'application/json'
+			});
+			res.end();
+		},
+		"/xml/empty" : function(req, res) {
+			res.writeHead(204, {
+				'Content-Type' : 'application/xml'
+			});
+			res.end();
+		},
+		"/json/contenttypewithspace" : function(req, res) {
+			var message = fs.readFileSync('./message.json', 'utf8');
+			res.writeHead(200, {
+				'Content-Type' : 'application/json; charset=utf-8'
+			});
+			res.write(message.toString());
+			res.end();
+		},
+		"/json/test/content/type" : function(req, res) {
+			var message = fs.readFileSync(RouterOptions.JSONMessageFile, 'utf8');
+			res.writeHead(200, {
+				'Content-Type' : 'test/json'
+			});
+			res.write(message.toString());
+			res.end();
+		},
+		"/xml/test/content/type" : function(req, res) {
+			var message = fs.readFileSync(RouterOptions.XMLMessageFile, 'utf8');
+			res.writeHead(200, {
+				'Content-Type' : 'test/xml'
+			});
+			res.write(message.toString());
+			res.end();
+		},
+		"/followRedirects":function(req, res){
+
+			var repeatOffset = req.url.indexOf("?"),
+			repeat = parseInt(req.url.substring(repeatOffset + 1),10),
+			location  = "";
+
+			if (repeatOffset === 0){
+				res.writeHead(301, {
+					'Location':'http://localhost:4444/redirected'
+				});
+			}else{
+				if (repeat > 0){
+					res.writeHead(301, {
+						'Location':'http://localhost:4444/followRedirects?' + --repeat
+					});
+				}else{
+					res.writeHead(301, {
+						'Location':'http://localhost:4444/redirected'
+					});
+				}
+
+			}
+			res.end();
+		},
+		"/redirected":function(req, res){
+			var message={"redirected":++this.redirectCount};
+			res.writeHead(200, {
+				'Content-Type' : 'application/json; charset=utf-8'
+			});
+			res.write(JSON.stringify(message));
+			res.end();
+		}
+
+	},
+	"sleep" : function(ms) {
+
+		var stop = new Date().getTime();
+		while (new Date().getTime() < stop + ms) {
+			;
+		}
+	},
+	"redirectCount":0,
+	"redirectLimit":10
+
+};
+
+// Create an HTTP server
+this.server = http.createServer(function(req, res) {
+	// console.log("[SERVER] req.url", req.url);
+	RouteManager.findRoute(req, res);
+});
+
+exports.baseURL = "http://localhost:4444";
+
+exports.listen = function() {
+	this.server.listen.apply(this.server, arguments);
+};
+
+exports.close = function(callback) {
+	this.server.close(callback);
+};
+
+exports.on = function(event, cb) {
+	this.server.on.apply(this.server, event, cb);
+};

node_modules/node-rest-client/test/specs/TestErrorHandlers.js

@@ -0,0 +1,54 @@
+var server =require("../server/mock-server"),
+Client=require("../../lib/node-rest-client").Client;
+
+describe('Error Handlers', function () {
+	
+  this.timeout(150000);
+	
+  before(function () {
+    server.listen(4444);
+    console.log("server started on port 4444");
+  });
+
+  describe("Client Error Hanlers",function(){
+
+
+    it("handle error with client handler", function(done){
+      var client = new Client();
+      client.on('error', function(err){        
+        done();
+      });
+      client.get(server.baseURL + "/json/error", function(data, response){
+        client.emit('error', response.status);  
+      });
+
+    });
+
+
+
+
+  });
+
+describe("#Request Error Handlers",function(){
+
+   it("handle error with request handler", function(done){
+      var client = new Client();
+
+      var req =client.get(server.baseURL + "/json/error", function(data, response){
+        req.emit('error', response.status); 
+      });
+
+      req.on('error',function(err){
+        done();
+      })
+
+    });
+
+});
+
+after(function () {
+  server.close();
+  console.log("server stopped");
+});
+
+});

node_modules/node-rest-client/test/specs/TestFollowsRedirect.js

@@ -0,0 +1,70 @@
+var server =require("../server/mock-server"),
+Client=require("../../lib/node-rest-client").Client;
+
+describe('Follows Redirects', function () {
+	
+  this.timeout(150000);
+	
+  before(function () {
+    server.listen(4444);
+    console.log("server started on port 4444");
+  });
+
+
+  describe("#Follows Redirects",function(){
+
+    it("follows Redirect", function(done){
+      var client = new Client();
+
+      client.post(server.baseURL + "/followRedirects", function(data, response){
+        data.should.not.equal(null);
+        data.should.type("object");
+        data.redirected.should.equal(1);        
+        done();
+      });
+
+    });
+
+    it("disable follows Redirect", function(done){
+      var client = new Client();
+      var args ={
+        requestConfig:{followRedirects:false}
+      };
+
+      client.post(server.baseURL + "/followRedirects",args, function(data, response){
+        response.statusCode.should.be.equal(301);       
+        done();
+      });
+
+    });
+
+
+
+    it("set max redirects", function(done){
+      var client = new Client();
+      var args ={
+        requestConfig:{maxRedirects:3}
+      };
+
+
+
+      var req = client.post(server.baseURL + "/followRedirects?5",args, function(data, response){
+        response.statusCode.should.be.equal(301);      
+        
+      });
+
+      req.on('error', function(err){
+        err.message.should.be.equal("Max redirects exceeded.")        
+        done();
+      });
+
+    });
+  });
+
+
+
+after(function () {
+  server.close();
+  console.log("server stopped");
+});
+});

node_modules/node-rest-client/test/specs/TestGETMethod.js

@@ -0,0 +1,232 @@
+var server =require("../server/mock-server"),
+Client=require("../../lib/node-rest-client").Client;
+
+describe('GET Method', function () {
+	
+  this.timeout(150000);
+	
+  before(function () {
+    server.listen(4444);
+    console.log("server started on port 4444");
+  });
+
+  describe("#JSON",function(){
+
+    it("GET request with no args", function(done){
+      var client = new Client();
+      client.get(server.baseURL + "/json", function(data, response){
+        data.should.not.equal(null);
+        data.should.type("object");
+        done();
+      });
+    });
+
+    it("GET request with path variable substitution", function(done){
+      var client = new Client();
+      var args ={
+        path:{testNumber:123, testString:"test"}
+      };
+      client.get(server.baseURL + "/json/path/${testNumber}/${testString}",args, function(data, response){
+
+        data.should.not.equal(null);
+        data.should.type("object");
+        data.url.should.equal("/json/path/123/test");
+        done();
+      });
+    });
+
+
+    it("GET request with parameters", function(done){
+      var client = new Client();
+      var args ={
+        parameters:{testNumber:123, testString:"test"}
+      };
+      client.get(server.baseURL + "/json/path/query",args, function(data, response){
+
+        data.should.not.equal(null);
+        data.should.type("object");
+        data.url.should.equal("/json/path/query?testNumber=123&testString=test");
+        done();
+      });
+    });
+
+    it("GET request with registered method and no args", function(done){
+      var client = new Client();
+
+
+      client.registerMethod("testMethod",server.baseURL + "/json","GET");
+
+      client.methods.testMethod( function(data, response){
+        data.should.not.equal(null);
+        data.should.type("object");
+        done();
+      });
+    });
+
+
+
+    it("GET request with registered method and path variable substitution", function(done){
+      var client = new Client();
+      var args ={
+        path:{testNumber:123, testString:"test"}
+      };
+
+      client.registerMethod("testMethod",server.baseURL + "/json/path/${testNumber}/${testString}","GET");
+
+      client.methods.testMethod(args, function(data, response){
+        data.should.not.equal(null);
+        data.should.type("object");
+        data.url.should.equal("/json/path/123/test");
+        done();
+      });
+    });
+
+
+    it("GET request with registered method and parameters", function(done){
+      var client = new Client();
+      var args ={
+        parameters:{testNumber:123, testString:"test"}
+      };
+
+      client.registerMethod("testMethod",server.baseURL + "/json/path/query","GET");
+
+      client.methods.testMethod(args, function(data, response){
+        data.should.not.equal(null);
+        data.should.type("object");
+        data.url.should.equal("/json/path/query?testNumber=123&testString=test");
+        
+        done();
+      });
+    });
+
+    it("GET request with incompatible parameters URL", function(done){
+      var client = new Client();
+      var args ={
+        parameters:{testNumber:123, testString:"test"}
+      };
+
+      client.on('error', function(err){
+        err.should.startWith("parameters argument cannot be used if parameters are already defined in URL");
+        done();
+      });
+
+      client.get(server.baseURL + "/json/path/query?testNumber=123&testString=test", args, function(data, response){
+        //noop
+      }).should.throw();
+
+    });
+
+    it("GET request with invalid args type", function(done){
+      var client = new Client();
+      var args = "123";
+
+      client.on('error', function(err){
+        err.should.startWith("args should be and object");
+        done();
+      });
+
+      
+
+      client.get(server.baseURL + "/json/path/query",args, function(data, response){
+        //noop
+      }).should.throw();
+
+    });
+
+
+    it("GET request with invalid parameters type", function(done){
+      var client = new Client();
+      var args ={
+        parameters:"{test='123'}"
+      };
+
+      client.on('error', function(err){
+        err.should.startWith("cannot serialize");
+        done();
+      });
+
+      
+
+      client.get(server.baseURL + "/json/path/query",args, function(data, response){
+        //noop
+      }).should.throw();
+
+    });
+
+    it("GET request with registered method and incompatible parameters URL", function(done){
+      var client = new Client();
+      var args ={
+        parameters:{testNumber:123, testString:"test"}
+      };
+
+      client.on('error', function(err){
+        err.should.startWith("parameters argument cannot be used if parameters are already defined in URL");
+        done();
+      });
+
+      client.registerMethod("testMethod",server.baseURL + "/json/path/query?testNumber=123&testString=test","GET");
+
+      client.methods.testMethod(args, function(data, response){
+        //noop
+      }).should.throw();
+
+    });
+
+    it("GET request with registered method and invalid args type", function(done){
+      var client = new Client();
+      var args ="123";
+
+      client.on('error', function(err){
+        err.should.startWith("args should be and object");
+        done();
+      });
+
+      client.registerMethod("testMethod",server.baseURL + "/json/path/query","GET");
+
+      client.methods.testMethod(args, function(data, response){
+        //noop
+      }).should.throw();
+
+    });
+
+
+    it("GET request with registered method and invalid parameters type", function(done){
+      var client = new Client();
+      var args ={
+        parameters:"{test='123'}"
+      };
+
+      client.on('error', function(err){
+        err.should.startWith("cannot serialize");
+        done();
+      });
+
+      client.registerMethod("testMethod",server.baseURL + "/json/path/query","GET");
+
+      client.methods.testMethod(args, function(data, response){
+        //noop
+      }).should.throw();
+
+    });
+  });
+
+
+describe("#XML",function(){
+
+  it("GET request with no args", function(done){
+    var client = new Client();
+    client.get(server.baseURL + "/xml", function(data, response){
+      console.log("data es ", data);
+      data.should.not.equal(null);
+      data.should.type("object");
+      done();
+    });
+  });
+
+});
+
+after(function () {
+  server.close();
+  console.log("server stopped");
+});
+});

node_modules/node-rest-client/test/specs/TestPOSTMethod.js

@@ -0,0 +1,241 @@
+var server =require("../server/mock-server"),
+Client=require("../../lib/node-rest-client").Client;
+
+describe('POST Method', function () {
+	
+  this.timeout(150000);
+	
+  before(function () {
+    server.listen(4444);
+    console.log("server started on port 4444");
+  });
+
+  describe("#JSON",function(){
+
+    it("POST request with path variable substitution", function(done){
+      var client = new Client();
+      var args ={
+        path:{testNumber:123, testString:"test"},
+        data:'{"dataNumber":123, "dataString":"test"}'
+
+      };
+      client.post(server.baseURL + "/json/path/post/${testNumber}/${testString}",args, function(data, response){
+        data.should.not.equal(null);
+        data.should.type("object");
+        data.url.should.equal("/json/path/post/123/test");
+        data.postData.should.equal('{"dataNumber":123, "dataString":"test"}');
+        done();
+      });
+    });
+
+
+    it("POST request with parameters", function(done){
+      var client = new Client();
+      var args ={
+        parameters:{testNumber:123, testString:"test"},
+        data:'{"dataNumber":123,"dataString":"test"}'
+      };
+      client.post(server.baseURL + "/json/path/post/query",args, function(data, response){
+
+        data.should.not.equal(null);
+        data.should.type("object");
+        data.url.should.equal("/json/path/post/query?testNumber=123&testString=test");
+        data.postData.should.equal('{"dataNumber":123,"dataString":"test"}');
+        done();
+      });
+    });
+
+    it("POST request with registered method and no args", function(done){
+      var client = new Client();
+
+
+      client.registerMethod("testMethod",server.baseURL + "/json","POST");
+
+      client.methods.testMethod( function(data, response){
+        data.should.not.equal(null);
+        data.should.type("object");
+        done();
+      });
+    });
+
+
+
+    it("POST request with registered method and path variable substitution", function(done){
+      var client = new Client();
+      var args ={
+        path:{testNumber:123, testString:"test"},
+        data:'{"dataNumber":123,"dataString":"test"}'
+      };
+
+      client.registerMethod("testMethod",server.baseURL + "/json/path/post/${testNumber}/${testString}","POST");
+
+      client.methods.testMethod(args, function(data, response){
+        data.should.not.equal(null);
+        data.should.type("object");
+        data.url.should.equal("/json/path/post/123/test");
+        data.postData.should.equal('{"dataNumber":123,"dataString":"test"}');
+        done();
+      });
+    });
+
+
+    it("POST request with registered method and parameters", function(done){
+      var client = new Client();
+      var args ={
+        parameters:{testNumber:123, testString:"test"},
+        data:'{"dataNumber":123,"dataString":"test"}'
+      };
+
+      client.registerMethod("testMethod",server.baseURL + "/json/path/post/query","POST");
+
+      client.methods.testMethod(args, function(data, response){
+        data.should.not.equal(null);
+        data.should.type("object");
+        data.url.should.equal("/json/path/post/query?testNumber=123&testString=test");
+        data.postData.should.equal('{"dataNumber":123,"dataString":"test"}');
+        done();
+      });
+    });
+
+    it("POST request with incompatible parameters URL", function(done){
+      var client = new Client();
+      var args ={
+        parameters:{testNumber:123, testString:"test"},
+        data:{dataNumber:123, dataString:"test"}
+      };
+
+      client.on('error', function(err){
+        err.should.startWith("parameters argument cannot be used if parameters are already defined in URL");
+        done();
+      });
+
+      client.post(server.baseURL + "/json/path/post/query?testNumber=123&testString=test", args, function(data, response){
+        // noop
+      }).should.throw();
+
+    });
+
+    it("POST request with invalid args type", function(done){
+      var client = new Client();
+      var args = "123";
+
+      client.on('error', function(err){
+        err.should.startWith("args should be and object");
+        done();
+      });
+
+      
+
+      client.post(server.baseURL + "/json/path/post/query",args, function(data, response){
+        // noop
+      }).should.throw();
+
+    });
+
+
+    it("POST request with invalid parameters type", function(done){
+      var client = new Client();
+      var args ={
+        parameters:"{test='123'}"
+      };
+
+      client.on('error', function(err){
+        err.should.startWith("cannot serialize");
+        done();
+      });
+
+      
+
+      client.post(server.baseURL + "/json/path/post/query",args, function(data, response){
+        // noop
+      }).should.throw();
+
+    });
+
+    it("POST request with registered method and incompatible parameters URL", function(done){
+      var client = new Client();
+      var args ={
+        parameters:{testNumber:123, testString:"test"},
+        data:{dataNumber:123, dataString:"test"}
+      };
+
+      client.on('error', function(err){
+        err.should.startWith("parameters argument cannot be used if parameters are already defined in URL");
+        done();
+      });
+
+      client.registerMethod("testMethod",server.baseURL + "/json/path/post/query?testNumber=123&testString=test","POST");
+
+      client.methods.testMethod(args, function(data, response){
+        // noop
+      }).should.throw();
+
+    });
+
+    it("POST request with registered method and invalid args type", function(done){
+      var client = new Client();
+      var args ="123";
+
+      client.on('error', function(err){
+        err.should.startWith("args should be and object");
+        done();
+      });
+
+      client.registerMethod("testMethod",server.baseURL + "/json/path/post/query","POST");
+
+      client.methods.testMethod(args, function(data, response){
+        // noop
+      }).should.throw();
+
+    });
+
+
+    it("POST request with registered method and invalid parameters type", function(done){
+      var client = new Client();
+      var args ={
+        parameters:"{test='123'}"
+      };
+
+      client.on('error', function(err){
+        err.should.startWith("cannot serialize");
+        done();
+      });
+
+      client.registerMethod("testMethod",server.baseURL + "/json/path/post/query","POST");
+
+      client.methods.testMethod(args, function(data, response){
+        // noop
+      }).should.throw();
+
+    });
+  });
+
+describe("#XML",function(){
+
+    it("POST request with parameters", function(done){
+      var client = new Client();
+      var args ={
+        data:"<?xml version='1.0'?><testData><testNumber>123</testNumber><testString>123</testString></testData>"
+      };
+      client.post(server.baseURL + "/xml/path/post/query",args, function(data, response){ 
+        data.should.type("object");
+        data.testData.should.be.ok;
+        data.testData.testNumber.should.be.ok;
+        data.testData.testString.should.be.ok;
+        data.testData.testNumber.should.be.a.Number;
+        data.testData.testString.should.be.a.String;        
+        data.testData.testNumber.should.be.equal("123");
+        data.testData.testString.should.be.equal("123");
+      
+        
+        done();
+      });
+    });
+
+});
+
+after(function () {
+  server.close();
+  console.log("server stopped");
+});
+});

node_modules/node-rest-client/test/specs/TestRIOFacade.js

@@ -0,0 +1,317 @@
+var server =require("../server/mock-server"),
+Client=require("../../lib/node-rest-client").Client;
+
+describe('IO Facade', function () {
+
+  this.timeout(150000);
+  
+  before(function () {
+    server.listen(4444);
+    console.log("server started on port 4444");
+  });
+
+  describe("#Parsers",function(){
+
+	  var  testParser = {"name":"test-parser",
+			  "isDefault":false,
+			  "match":function(response){
+				  return response.headers["test-header"] === "test";			  
+			  	},
+			  "parse":function(byteBuffer,nrcEventEmitter,parsedCallback){
+				  var message = JSON.parse(byteBuffer.toString());
+				  message.parsed = true;
+				  parsedCallback(message);
+			  	}
+			  },
+			defaultTestParser = {"name":"default-test-parser",
+					  "isDefault":true,
+					  "parse":function(byteBuffer,nrcEventEmitter,parsedCallback){
+						  var message = JSON.parse(byteBuffer.toString());
+						  message.defaultParsed = true;
+						  parsedCallback(message);
+					  	}
+					  };   
+	  
+    it("add invalid parser to client", function(done){
+      var client = new Client();
+
+      client.on('error', function(err){
+        err.should.startWith("parser cannot be added: invalid parser definition");
+        done();
+      });
+
+      client.parsers.add({"invalid":123, "parser":456}).should.throw();
+    });
+
+    
+    it("add parser to client", function(done){
+        var client = new Client();     
+        client.parsers.add(testParser);
+        var parser = client.parsers.find("test-parser");        
+        
+        parser.should.not.equal(null);
+        parser.should.type("object");
+        done();
+      });
+    
+    
+    it("remove parser from client", function(done){
+        var client = new Client();
+        
+        client.on('error', function(err){
+            err.should.startWith("cannot find parser: test-parser doesn't exists");
+            done();
+          });
+        
+        client.parsers.add(testParser);
+        var parser = client.parsers.find("test-parser");        
+        
+        parser.should.not.equal(null);
+        parser.should.type("object");
+        
+        client.parsers.remove("test-parser");        
+        client.parsers.find("test-parser");
+      });
+    
+    it("response match parser", function(done){
+        var client = new Client();
+        client.parsers.clean();
+        client.parsers.add(testParser);
+                
+        client.get(server.baseURL + "/json", function(data, response){
+            data.should.not.equal(null);
+            data.should.type("object");
+            data.should.have.property("parsed");
+            data.parsed.should.be.a.Boolean;
+            data.parsed.should.be.true;
+            done();
+          });       
+
+      });
+    
+    
+    it("add and use default parser", function(done){
+        var client = new Client();
+        client.parsers.clean();
+        
+        client.parsers.add(testParser);
+        client.parsers.add(defaultTestParser);
+        // no parsers defined, default must be used
+                
+        client.get(server.baseURL + "/json/path?default-test", function(data, response){
+            data.should.not.equal(null);
+            data.should.type("object"); 
+            data.should.have.property("defaultParsed");
+            data.defaultParsed.should.be.a.Boolean;
+            data.defaultParsed.should.be.true;
+            done();
+          });       
+
+      });
+    
+    
+    it("add custom types to args in JSON parser", function(done){
+    	var options={
+    			// customize mime types for json or xml connections 
+    		    mimetypes: {
+    		        json: ["test/json"]    		        
+    		    }
+    	};
+        var client = new Client(options);
+        
+        client.get(server.baseURL + "/json/test/content/type", function(data, response){
+            data.should.not.equal(null);
+            data.should.type("object");
+            done();
+          });        
+        
+      });
+    
+    
+    it("add custom types to args in XML parser", function(done){
+    	var options={
+    			// customize mime types for json or xml connections 
+    		    mimetypes: {
+    		        xml: ["test/xml"]
+    		    }
+    	};
+        var client = new Client(options);
+        
+        client.get(server.baseURL + "/xml/test/content/type", function(data, response){
+            data.should.not.equal(null);
+            data.should.type("object");
+            done();
+          });        
+        
+      });
+
+
+   it("get all regular parsers", function(done){
+
+        var client = new Client();
+ 		var parsers = client.parsers.getAll();
+ 		parsers.should.have.length(2);
+ 		done();        
+        
+      });
+
+	   it("emit custom event from parser to client", function(done){
+	        var client = new Client();
+	        client.on('customEvent',function(event){
+	        	event.should.be.equal("my custom event");
+	        	done();
+	        });
+
+
+	        client.parsers.clean();
+	        client.parsers.add({
+						"name":"example-parser",
+						"isDefault":false,
+						"match":function(request){return true; },							
+						"parse":function(byteBuffer,nrcEventEmitter,parsedCallback){							
+							nrcEventEmitter('customEvent','my custom event');
+							// pass serialized data to client to be sent to remote API
+							parsedCallback(byteBuffer.toString());
+
+						}
+					});
+	        
+	        var args ={data:"test data"}
+      
+      		client.post(server.baseURL + "/json/path/post/query",args, function(data, response){});
+
+	      });
+
+  });
+
+
+describe("#Serializers",function(){
+
+	  var  testSerializer = {"name":"test-serializer",
+			  "isDefault":false,
+			  "match":function(request){
+				  return request.headers["test-header"] === "test";			  
+			  	},
+			  "serialize":function(data,nrcEventEmitter,serializedCallback){
+				  if (typeof data === 'object')
+					  data.serialized = true;				  
+				  serializedCallback(JSON.stringify(data));
+			  	}
+			  },
+			defaultTestSerializer = {"name":"default-test-serializer",
+					  "isDefault":true,
+					  "serialize":function(data,nrcEventEmitter,serializedCallback){
+						  if (typeof data === 'object')
+							  data.defaultParsed = true;						  
+						  serializedCallback(data);
+					  	}
+					  };  
+
+	  
+	  it("add invalid serializer to client", function(done){
+	      var client = new Client();
+
+	      client.on('error', function(err){
+	        err.should.startWith("serializer cannot be added: invalid serializer definition");
+	        done();
+	      });
+
+	      client.serializers.add({"invalid":123, "serializer":456}).should.throw();
+	    });
+
+	  
+	  
+	    it("add serializer to client", function(done){
+	        var client = new Client();     
+	        client.serializers.add(testSerializer);
+	        var serializer = client.serializers.find("test-serializer");        
+	        
+	        serializer.should.not.equal(null);
+	        serializer.should.type("object");
+	        done();
+	      });
+	    
+	    
+	    it("remove serializer from client", function(done){
+	        var client = new Client();
+	        
+	        client.on('error', function(err){
+	            err.should.startWith("cannot find serializer: test-serializer doesn't exists");
+	            done();
+	          });
+	        
+	        client.serializers.add(testSerializer);
+	        var serializer = client.serializers.find("test-serializer");        
+	        
+	        serializer.should.not.equal(null);
+	        serializer.should.type("object");
+	        
+	        client.serializers.remove("test-serializer");        
+	        client.serializers.find("test-serializer");
+	      });
+	    
+	    
+	    it("request match serializer", function(done){
+	        var client = new Client(),
+	        args={
+	        	headers:{"test-header":"test"},
+	        	data:{"testNumber":123, "testString":"abc"}	        
+	        };
+	        
+	        client.serializers.clean();
+	        client.serializers.add(testSerializer);
+	                
+	        var request = client.post(server.baseURL + "/json/path/post",args, function(data, response){
+	            data.postData.should.not.equal(null);
+	            data.postData.should.type("object");
+	            data.postData.should.have.property("serialized");
+	            data.postData.serialized.should.be.a.Boolean;
+	            data.postData.serialized.should.be.true;	            
+	          });       
+
+	        done();
+	        
+	      });
+
+   it("get all regular serializers", function(done){
+
+        var client = new Client();
+ 		var serializers = client.serializers.getAll();
+ 		serializers.should.have.length(3);
+ 		done();        
+        
+      });
+
+	   it("emit custom event from serializer to client", function(done){
+	        var client = new Client();
+	        client.on('customEvent',function(event){
+	        	event.should.be.equal("my custom event");
+	        	done();
+	        });
+
+
+	        client.serializers.clean();
+	        client.serializers.add({
+						"name":"example-serializer",
+						"isDefault":false,
+						"match":function(request){return true; },							
+						"serialize":function(data,nrcEventEmitter,serializedCallback){							
+							nrcEventEmitter('customEvent','my custom event');
+							// pass serialized data to client to be sent to remote API
+							serializedCallback(data.toString());
+
+						}
+					});
+	        
+	        var args ={data:"test data"}
+      
+      		client.post(server.baseURL + "/json/path/post/query",args, function(data, response){});
+
+	      });
+
+});
+
+after(function () {
+  server.close();  
+});
+});

node_modules/node-rest-client/test/test-proxy.js

@@ -0,0 +1,91 @@
+var http = require('http');
+var fs   = require('fs');
+
+var blacklist = [];
+var iplist    = [];
+
+fs.watchFile('./blacklist', function(c,p) { update_blacklist(); });
+fs.watchFile('./iplist', function(c,p) { update_iplist(); });
+
+function update_blacklist() {
+  console.log("Updating blacklist.");
+  blacklist = fs.readFileSync('./blacklist', {encoding: 'utf-8'}).split('\n')
+              .filter(function(rx) { return rx.length })
+              .map(function(rx) { return RegExp(rx) });
+}
+
+function update_iplist() {
+  console.log("Updating iplist.");
+  iplist = fs.readFileSync('./iplist', {encoding: 'utf-8'}).split('\n')
+           .filter(function(rx) { return rx.length });
+}
+
+function ip_allowed(ip) {
+  for (i in iplist) {
+    if (iplist[i] == ip) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function host_allowed(host) {
+  for (i in blacklist) {
+    if (blacklist[i].test(host)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function deny(response, msg) {
+  response.writeHead(401);
+  response.write(msg);
+  response.end();
+}
+
+http.createServer(function(request, response) {
+  var ip = request.connection.remoteAddress;
+  if (!ip_allowed(ip)) {
+    msg = "IP " + ip + " is not allowed to use this proxy";
+    deny(response, msg);
+    console.log(msg);
+    return;
+  }
+
+  if (!host_allowed(request.url)) {
+    msg = "Host " + request.url + " has been denied by proxy configuration";
+    deny(response, msg);
+    console.log(msg);
+    return;
+  }
+
+  console.log(ip + ": " + request.method + " " + request.url);
+  var agent = new http.Agent({ host: request.headers['host'], port: 80, maxSockets: 1 });
+  var proxy_request = http.request({
+    host: request.headers['host'],
+    port: 80,
+    method: request.method,
+    path: request.url,
+    headers: request.headers,
+    agent: agent
+  });
+  proxy_request.addListener('response', function(proxy_response) {
+    proxy_response.addListener('data', function(chunk) {
+      response.write(chunk, 'binary');
+    });
+    proxy_response.addListener('end', function() {
+      response.end();
+    });
+    response.writeHead(proxy_response.statusCode, proxy_response.headers);
+  });
+  request.addListener('data', function(chunk) {
+    proxy_request.write(chunk, 'binary');
+  });
+  request.addListener('end', function() {
+    proxy_request.end();
+  });
+}).listen(8080);
+
+update_blacklist();
+update_iplist();