| /* |
| * http.js: Macros for proxying HTTP requests |
| * |
| * (C) 2010 Nodejitsu Inc. |
| * MIT LICENCE |
| * |
| */ |
| |
| var assert = require('assert'), |
| fs = require('fs'), |
| async = require('async'), |
| net = require('net'), |
| request = require('request'), |
| helpers = require('../helpers/index'); |
| |
| // |
| // ### function assertRequest (options) |
| // #### @options {Object} Options for this request assertion. |
| // #### @request {Object} Options to use for `request`. |
| // #### @assert {Object} Test assertions against the response. |
| // |
| // Makes a request using `options.request` and then asserts the response |
| // and body against anything in `options.assert`. |
| // |
| exports.assertRequest = function (options) { |
| return { |
| topic: function () { |
| // |
| // Now make the HTTP request and assert. |
| // |
| options.request.rejectUnauthorized = false; |
| request(options.request, this.callback); |
| }, |
| "should succeed": function (err, res, body) { |
| assert.isNull(err); |
| if (options.assert.headers) { |
| Object.keys(options.assert.headers).forEach(function(header){ |
| assert.equal(res.headers[header], options.assert.headers[header]); |
| }); |
| } |
| |
| if (options.assert.body) { |
| assert.equal(body, options.assert.body); |
| } |
| |
| if (options.assert.statusCode) { |
| assert.equal(res.statusCode, options.assert.statusCode); |
| } |
| } |
| }; |
| }; |
| |
| // |
| // ### function assertFailedRequest (options) |
| // #### @options {Object} Options for this failed request assertion. |
| // #### @request {Object} Options to use for `request`. |
| // #### @assert {Object} Test assertions against the response. |
| // |
| // Makes a request using `options.request` and then asserts the response |
| // and body against anything in `options.assert`. |
| // |
| exports.assertFailedRequest = function (options) { |
| return { |
| topic: function () { |
| // |
| // Now make the HTTP request and assert. |
| // |
| options.request.rejectUnauthorized = false; |
| request(options.request, this.callback); |
| }, |
| "should not succeed": function (err, res, body) { |
| assert.notStrictEqual(err,null); |
| } |
| }; |
| }; |
| |
| // |
| // ### function assertProxied (options) |
| // #### @options {Object} Options for this test |
| // #### @latency {number} Latency in milliseconds for the proxy server. |
| // #### @ports {Object} Ports for the request (target, proxy). |
| // #### @output {string} Output to assert from. |
| // #### @forward {Object} Options for forward proxying. |
| // |
| // Creates a complete end-to-end test for requesting against an |
| // http proxy. |
| // |
| exports.assertProxied = function (options) { |
| options = options || {}; |
| |
| var ports = options.ports || helpers.nextPortPair, |
| output = options.output || 'hello world from ' + ports.target, |
| outputHeaders = options.outputHeaders, |
| targetHeaders = options.targetHeaders, |
| proxyHeaders = options.proxyHeaders, |
| protocol = helpers.protocols.proxy, |
| req = options.request || {}, |
| timeout = options.timeout || null, |
| assertFn = options.shouldFail |
| ? exports.assertFailedRequest |
| : exports.assertRequest; |
| |
| req.uri = req.uri || protocol + '://127.0.0.1:' + ports.proxy; |
| |
| return { |
| topic: function () { |
| // |
| // Create a target server and a proxy server |
| // using the `options` supplied. |
| // |
| helpers.http.createServerPair({ |
| target: { |
| output: output, |
| outputHeaders: targetHeaders, |
| port: ports.target, |
| headers: req.headers, |
| latency: options.requestLatency |
| }, |
| proxy: { |
| latency: options.latency, |
| port: ports.proxy, |
| outputHeaders: proxyHeaders, |
| proxy: { |
| forward: options.forward, |
| target: { |
| https: helpers.protocols.target === 'https', |
| host: '127.0.0.1', |
| port: ports.target |
| }, |
| timeout: timeout |
| } |
| } |
| }, this.callback); |
| }, |
| "the proxy request": assertFn({ |
| request: req, |
| assert: { |
| headers: outputHeaders, |
| body: output |
| } |
| }) |
| }; |
| }; |
| |
| // |
| // ### function assertRawHttpProxied (options) |
| // #### @options {Object} Options for this test |
| // #### @rawRequest {string} Raw HTTP request to perform. |
| // #### @match {RegExp} Output to match in the response. |
| // #### @latency {number} Latency in milliseconds for the proxy server. |
| // #### @ports {Object} Ports for the request (target, proxy). |
| // #### @output {string} Output to assert from. |
| // #### @forward {Object} Options for forward proxying. |
| // |
| // Creates a complete end-to-end test for requesting against an |
| // http proxy. |
| // |
| exports.assertRawHttpProxied = function (options) { |
| // Don't test raw requests over HTTPS since options.rawRequest won't be |
| // encrypted. |
| if(helpers.protocols.proxy == 'https') { |
| return true; |
| } |
| |
| options = options || {}; |
| |
| var ports = options.ports || helpers.nextPortPair, |
| output = options.output || 'hello world from ' + ports.target, |
| outputHeaders = options.outputHeaders, |
| targetHeaders = options.targetHeaders, |
| proxyHeaders = options.proxyHeaders, |
| protocol = helpers.protocols.proxy, |
| timeout = options.timeout || null, |
| assertFn = options.shouldFail |
| ? exports.assertFailedRequest |
| : exports.assertRequest; |
| |
| return { |
| topic: function () { |
| var topicCallback = this.callback; |
| |
| // |
| // Create a target server and a proxy server |
| // using the `options` supplied. |
| // |
| helpers.http.createServerPair({ |
| target: { |
| output: output, |
| outputHeaders: targetHeaders, |
| port: ports.target, |
| latency: options.requestLatency |
| }, |
| proxy: { |
| latency: options.latency, |
| port: ports.proxy, |
| outputHeaders: proxyHeaders, |
| proxy: { |
| forward: options.forward, |
| target: { |
| https: helpers.protocols.target === 'https', |
| host: '127.0.0.1', |
| port: ports.target |
| }, |
| timeout: timeout |
| } |
| } |
| }, function() { |
| var response = ''; |
| var client = net.connect(ports.proxy, '127.0.0.1', function() { |
| client.write(options.rawRequest); |
| }); |
| |
| client.on('data', function(data) { |
| response += data.toString(); |
| }); |
| |
| client.on('end', function() { |
| topicCallback(null, options.match, response); |
| }); |
| }); |
| }, |
| "should succeed": function(err, match, response) { |
| assert.match(response, match); |
| } |
| }; |
| }; |
| |
| // |
| // ### function assertInvalidProxy (options) |
| // #### @options {Object} Options for this test |
| // #### @latency {number} Latency in milliseconds for the proxy server |
| // #### @ports {Object} Ports for the request (target, proxy) |
| // |
| // Creates a complete end-to-end test for requesting against an |
| // http proxy with no target server. |
| // |
| exports.assertInvalidProxy = function (options) { |
| options = options || {}; |
| |
| var ports = options.ports || helpers.nextPortPair, |
| req = options.request || {}, |
| protocol = helpers.protocols.proxy; |
| |
| |
| req.uri = req.uri || protocol + '://127.0.0.1:' + ports.proxy; |
| |
| return { |
| topic: function () { |
| // |
| // Only create the proxy server, simulating a reverse-proxy |
| // to an invalid location. |
| // |
| helpers.http.createProxyServer({ |
| latency: options.latency, |
| port: ports.proxy, |
| proxy: { |
| target: { |
| host: '127.0.0.1', |
| port: ports.target |
| } |
| } |
| }, this.callback); |
| }, |
| "the proxy request": exports.assertRequest({ |
| request: req, |
| assert: { |
| statusCode: 500 |
| } |
| }) |
| }; |
| }; |
| |
| // |
| // ### function assertForwardProxied (options) |
| // #### @options {Object} Options for this test. |
| // |
| // Creates a complete end-to-end test for requesting against an |
| // http proxy with both a valid and invalid forward target. |
| // |
| exports.assertForwardProxied = function (options) { |
| var forwardPort = helpers.nextPort; |
| |
| return { |
| topic: function () { |
| helpers.http.createServer({ |
| output: 'hello from forward', |
| port: forwardPort |
| }, this.callback); |
| }, |
| "and a valid forward target": exports.assertProxied({ |
| forward: { |
| port: forwardPort, |
| host: '127.0.0.1' |
| } |
| }), |
| "and an invalid forward target": exports.assertProxied({ |
| forward: { |
| port: 9898, |
| host: '127.0.0.1' |
| } |
| }) |
| }; |
| }; |
| |
| // |
| // ### function assertProxiedtoRoutes (options, nested) |
| // #### @options {Object} Options for this ProxyTable-based test |
| // #### @routes {Object|string} Routes to use for the proxy. |
| // #### @hostnameOnly {boolean} Enables hostnameOnly routing. |
| // #### @nested {Object} Nested vows to add to the returned context. |
| // |
| // Creates a complete end-to-end test for requesting against an |
| // http proxy using `options.routes`: |
| // |
| // 1. Creates target servers for all routes in `options.routes.` |
| // 2. Creates a proxy server. |
| // 3. Ensure requests to the proxy server for all route targets |
| // returns the unique expected output. |
| // |
| exports.assertProxiedToRoutes = function (options, nested) { |
| // |
| // Assign dynamic ports to the routes to use. |
| // |
| options.routes = helpers.http.assignPortsToRoutes(options.routes); |
| |
| // |
| // Parse locations from routes for making assertion requests. |
| // |
| var locations = helpers.http.parseRoutes(options), |
| port = options.pport || helpers.nextPort, |
| protocol = helpers.protocols.proxy, |
| context, |
| proxy; |
| |
| if (options.filename) { |
| // |
| // If we've been passed a filename write the routes to it |
| // and setup the proxy options to use that file. |
| // |
| fs.writeFileSync(options.filename, JSON.stringify({ router: options.routes })); |
| proxy = { router: options.filename }; |
| } |
| else { |
| // |
| // Otherwise just use the routes themselves. |
| // |
| proxy = { |
| hostnameOnly: options.hostnameOnly, |
| pathnameOnly: options.pathnameOnly, |
| router: options.routes |
| }; |
| } |
| |
| // |
| // Set the https options if necessary |
| // |
| if (helpers.protocols.target === 'https') { |
| proxy.target = { https: true }; |
| } |
| |
| // |
| // Create the test context which creates all target |
| // servers for all routes and a proxy server. |
| // |
| context = { |
| topic: function () { |
| var that = this; |
| |
| async.waterfall([ |
| // |
| // 1. Create all the target servers |
| // |
| async.apply( |
| async.forEach, |
| locations, |
| function createRouteTarget(location, next) { |
| helpers.http.createServer({ |
| port: location.target.port, |
| output: 'hello from ' + location.source.href |
| }, next); |
| } |
| ), |
| // |
| // 2. Create the proxy server |
| // |
| async.apply( |
| helpers.http.createProxyServer, |
| { |
| port: port, |
| latency: options.latency, |
| routing: true, |
| proxy: proxy |
| } |
| ) |
| ], function (_, server) { |
| // |
| // 3. Set the proxy server for later use |
| // |
| that.proxyServer = server; |
| that.callback(); |
| }); |
| |
| // |
| // 4. Assign the port to the context for later use |
| // |
| this.port = port; |
| }, |
| // |
| // Add an extra assertion to a route which |
| // should respond with 404 |
| // |
| "a request to unknown.com": exports.assertRequest({ |
| assert: { statusCode: 404 }, |
| request: { |
| uri: protocol + '://127.0.0.1:' + port, |
| headers: { |
| host: 'unknown.com' |
| } |
| } |
| }) |
| }; |
| |
| // |
| // Add test assertions for each of the route locations. |
| // |
| locations.forEach(function (location) { |
| context[location.source.href] = exports.assertRequest({ |
| request: { |
| uri: protocol + '://127.0.0.1:' + port + location.source.path, |
| headers: { |
| host: location.source.hostname |
| } |
| }, |
| assert: { |
| body: 'hello from ' + location.source.href |
| } |
| }); |
| }); |
| |
| // |
| // If there are any nested vows to add to the context |
| // add them before returning the full context. |
| // |
| if (nested) { |
| Object.keys(nested).forEach(function (key) { |
| context[key] = nested[key]; |
| }); |
| } |
| |
| return context; |
| }; |
| |
| // |
| // ### function assertDynamicProxy (static, dynamic) |
| // Asserts that after the `static` routes have been tested |
| // and the `dynamic` routes are added / removed the appropriate |
| // proxy responses are received. |
| // |
| exports.assertDynamicProxy = function (static, dynamic) { |
| var proxyPort = helpers.nextPort, |
| protocol = helpers.protocols.proxy, |
| context; |
| |
| if (dynamic.add) { |
| dynamic.add = dynamic.add.map(function (dyn) { |
| dyn.port = helpers.nextPort; |
| dyn.target = dyn.target + dyn.port; |
| return dyn; |
| }); |
| } |
| |
| context = { |
| topic: function () { |
| var that = this; |
| |
| setTimeout(function () { |
| if (dynamic.drop) { |
| dynamic.drop.forEach(function (dropHost) { |
| that.proxyServer.proxy.removeHost(dropHost); |
| }); |
| } |
| |
| if (dynamic.add) { |
| async.forEachSeries(dynamic.add, function addOne (dyn, next) { |
| that.proxyServer.proxy.addHost(dyn.host, dyn.target); |
| helpers.http.createServer({ |
| port: dyn.port, |
| output: 'hello ' + dyn.host |
| }, next); |
| }, that.callback); |
| } |
| else { |
| that.callback(); |
| } |
| }, 200); |
| } |
| }; |
| |
| if (dynamic.drop) { |
| dynamic.drop.forEach(function (dropHost) { |
| context[dropHost] = exports.assertRequest({ |
| assert: { statusCode: 404 }, |
| request: { |
| uri: protocol + '://127.0.0.1:' + proxyPort, |
| headers: { |
| host: dropHost |
| } |
| } |
| }); |
| }); |
| } |
| |
| if (dynamic.add) { |
| dynamic.add.forEach(function (dyn) { |
| context[dyn.host] = exports.assertRequest({ |
| assert: { body: 'hello ' + dyn.host }, |
| request: { |
| uri: protocol + '://127.0.0.1:' + proxyPort, |
| headers: { |
| host: dyn.host |
| } |
| } |
| }); |
| }); |
| } |
| |
| static.pport = proxyPort; |
| return exports.assertProxiedToRoutes(static, { |
| "once the server has started": context |
| }); |
| }; |
