| /** | |
| * Module dependencies. | |
| */ | |
| var fs = require('fs'); | |
| var url = require('url'); | |
| var net = require('net'); | |
| var tls = require('tls'); | |
| var http = require('http'); | |
| var https = require('https'); | |
| var WebSocket = require('ws'); | |
| var assert = require('assert'); | |
| var events = require('events'); | |
| var inherits = require('util').inherits; | |
| var Agent = require('../'); | |
| var PassthroughAgent = Agent(function(req, opts) { | |
| return opts.secureEndpoint ? https.globalAgent : http.globalAgent; | |
| }); | |
| describe('Agent', function() { | |
| describe('subclass', function() { | |
| it('should be subclassable', function(done) { | |
| function MyAgent() { | |
| Agent.call(this); | |
| } | |
| inherits(MyAgent, Agent); | |
| MyAgent.prototype.callback = function(req, opts, fn) { | |
| assert.equal(req.path, '/foo'); | |
| assert.equal(req.getHeader('host'), '127.0.0.1:1234'); | |
| assert.equal(opts.secureEndpoint, true); | |
| done(); | |
| }; | |
| var info = url.parse('https://127.0.0.1:1234/foo'); | |
| info.agent = new MyAgent(); | |
| https.get(info); | |
| }); | |
| }); | |
| describe('options', function() { | |
| it('should support an options Object as first argument', function() { | |
| var agent = new Agent({ timeout: 1000 }); | |
| assert.equal(1000, agent.timeout); | |
| }); | |
| it('should support an options Object as second argument', function() { | |
| var agent = new Agent(function() {}, { timeout: 1000 }); | |
| assert.equal(1000, agent.timeout); | |
| }); | |
| it('should be mixed in with HTTP request options', function(done) { | |
| var agent = new Agent({ | |
| host: 'my-proxy.com', | |
| port: 3128, | |
| foo: 'bar' | |
| }); | |
| agent.callback = function(req, opts, fn) { | |
| assert.equal('bar', opts.foo); | |
| assert.equal('a', opts.b); | |
| // `host` and `port` are special-cases, and should always be | |
| // overwritten in the request `opts` inside the agent-base callback | |
| assert.equal('localhost', opts.host); | |
| assert.equal(80, opts.port); | |
| done(); | |
| }; | |
| var opts = { | |
| b: 'a', | |
| agent: agent | |
| }; | |
| http.get(opts); | |
| }); | |
| }); | |
| describe('`this` context', function() { | |
| it('should be the Agent instance', function(done) { | |
| var called = false; | |
| var agent = new Agent(); | |
| agent.callback = function() { | |
| called = true; | |
| assert.equal(this, agent); | |
| }; | |
| var info = url.parse('http://127.0.0.1/foo'); | |
| info.agent = agent; | |
| var req = http.get(info); | |
| req.on('error', function(err) { | |
| assert(/no Duplex stream was returned/.test(err.message)); | |
| done(); | |
| }); | |
| }); | |
| it('should be the Agent instance with callback signature', function(done) { | |
| var called = false; | |
| var agent = new Agent(); | |
| agent.callback = function(req, opts, fn) { | |
| called = true; | |
| assert.equal(this, agent); | |
| fn(); | |
| }; | |
| var info = url.parse('http://127.0.0.1/foo'); | |
| info.agent = agent; | |
| var req = http.get(info); | |
| req.on('error', function(err) { | |
| assert(/no Duplex stream was returned/.test(err.message)); | |
| done(); | |
| }); | |
| }); | |
| }); | |
| describe('"error" event', function() { | |
| it('should be invoked on `http.ClientRequest` instance if `callback()` has not been defined', function( | |
| done | |
| ) { | |
| var agent = new Agent(); | |
| var info = url.parse('http://127.0.0.1/foo'); | |
| info.agent = agent; | |
| var req = http.get(info); | |
| req.on('error', function(err) { | |
| assert.equal( | |
| '"agent-base" has no default implementation, you must subclass and override `callback()`', | |
| err.message | |
| ); | |
| done(); | |
| }); | |
| }); | |
| it('should be invoked on `http.ClientRequest` instance if Error passed to callback function on the first tick', function( | |
| done | |
| ) { | |
| var agent = new Agent(function(req, opts, fn) { | |
| fn(new Error('is this caught?')); | |
| }); | |
| var info = url.parse('http://127.0.0.1/foo'); | |
| info.agent = agent; | |
| var req = http.get(info); | |
| req.on('error', function(err) { | |
| assert.equal('is this caught?', err.message); | |
| done(); | |
| }); | |
| }); | |
| it('should be invoked on `http.ClientRequest` instance if Error passed to callback function after the first tick', function( | |
| done | |
| ) { | |
| var agent = new Agent(function(req, opts, fn) { | |
| setTimeout(function() { | |
| fn(new Error('is this caught?')); | |
| }, 10); | |
| }); | |
| var info = url.parse('http://127.0.0.1/foo'); | |
| info.agent = agent; | |
| var req = http.get(info); | |
| req.on('error', function(err) { | |
| assert.equal('is this caught?', err.message); | |
| done(); | |
| }); | |
| }); | |
| }); | |
| describe('artificial "streams"', function() { | |
| it('should send a GET request', function(done) { | |
| var stream = new events.EventEmitter(); | |
| // needed for the `http` module to call .write() on the stream | |
| stream.writable = true; | |
| stream.write = function(str) { | |
| assert(0 == str.indexOf('GET / HTTP/1.1')); | |
| done(); | |
| }; | |
| // needed for `http` module in Node.js 4 | |
| stream.cork = function() {}; | |
| var opts = { | |
| method: 'GET', | |
| host: '127.0.0.1', | |
| path: '/', | |
| port: 80, | |
| agent: new Agent(function(req, opts, fn) { | |
| fn(null, stream); | |
| }) | |
| }; | |
| var req = http.request(opts); | |
| req.end(); | |
| }); | |
| it('should receive a GET response', function(done) { | |
| var stream = new events.EventEmitter(); | |
| var opts = { | |
| method: 'GET', | |
| host: '127.0.0.1', | |
| path: '/', | |
| port: 80, | |
| agent: new Agent(function(req, opts, fn) { | |
| fn(null, stream); | |
| }) | |
| }; | |
| var req = http.request(opts, function(res) { | |
| assert.equal('1.0', res.httpVersion); | |
| assert.equal(200, res.statusCode); | |
| assert.equal('bar', res.headers.foo); | |
| assert.deepEqual(['1', '2'], res.headers['set-cookie']); | |
| done(); | |
| }); | |
| // have to wait for the "socket" event since `http.ClientRequest` | |
| // doesn't *actually* attach the listeners to the "stream" until | |
| // this happens | |
| req.once('socket', function() { | |
| var buf = Buffer.from( | |
| 'HTTP/1.0 200\r\n' + | |
| 'Foo: bar\r\n' + | |
| 'Set-Cookie: 1\r\n' + | |
| 'Set-Cookie: 2\r\n\r\n' | |
| ); | |
| stream.emit('data', buf); | |
| }); | |
| req.end(); | |
| }); | |
| }); | |
| }); | |
| describe('"http" module', function() { | |
| var server; | |
| var port; | |
| // setup test HTTP server | |
| before(function(done) { | |
| server = http.createServer(); | |
| server.listen(0, function() { | |
| port = server.address().port; | |
| done(); | |
| }); | |
| }); | |
| // shut down test HTTP server | |
| after(function(done) { | |
| server.once('close', function() { | |
| done(); | |
| }); | |
| server.close(); | |
| }); | |
| it('should work for basic HTTP requests', function(done) { | |
| var called = false; | |
| var agent = new Agent(function(req, opts, fn) { | |
| called = true; | |
| var socket = net.connect(opts); | |
| fn(null, socket); | |
| }); | |
| // add HTTP server "request" listener | |
| var gotReq = false; | |
| server.once('request', function(req, res) { | |
| gotReq = true; | |
| res.setHeader('X-Foo', 'bar'); | |
| res.setHeader('X-Url', req.url); | |
| res.end(); | |
| }); | |
| var info = url.parse('http://127.0.0.1:' + port + '/foo'); | |
| info.agent = agent; | |
| http.get(info, function(res) { | |
| assert.equal('bar', res.headers['x-foo']); | |
| assert.equal('/foo', res.headers['x-url']); | |
| assert(gotReq); | |
| assert(called); | |
| done(); | |
| }); | |
| }); | |
| it('should support direct return in `connect()`', function(done) { | |
| var called = false; | |
| var agent = new Agent(function(req, opts) { | |
| called = true; | |
| return net.connect(opts); | |
| }); | |
| // add HTTP server "request" listener | |
| var gotReq = false; | |
| server.once('request', function(req, res) { | |
| gotReq = true; | |
| res.setHeader('X-Foo', 'bar'); | |
| res.setHeader('X-Url', req.url); | |
| res.end(); | |
| }); | |
| var info = url.parse('http://127.0.0.1:' + port + '/foo'); | |
| info.agent = agent; | |
| http.get(info, function(res) { | |
| assert.equal('bar', res.headers['x-foo']); | |
| assert.equal('/foo', res.headers['x-url']); | |
| assert(gotReq); | |
| assert(called); | |
| done(); | |
| }); | |
| }); | |
| it('should support returning a Promise in `connect()`', function(done) { | |
| var called = false; | |
| var agent = new Agent(function(req, opts) { | |
| return new Promise(function(resolve, reject) { | |
| called = true; | |
| resolve(net.connect(opts)); | |
| }); | |
| }); | |
| // add HTTP server "request" listener | |
| var gotReq = false; | |
| server.once('request', function(req, res) { | |
| gotReq = true; | |
| res.setHeader('X-Foo', 'bar'); | |
| res.setHeader('X-Url', req.url); | |
| res.end(); | |
| }); | |
| var info = url.parse('http://127.0.0.1:' + port + '/foo'); | |
| info.agent = agent; | |
| http.get(info, function(res) { | |
| assert.equal('bar', res.headers['x-foo']); | |
| assert.equal('/foo', res.headers['x-url']); | |
| assert(gotReq); | |
| assert(called); | |
| done(); | |
| }); | |
| }); | |
| it('should set the `Connection: close` response header', function(done) { | |
| var called = false; | |
| var agent = new Agent(function(req, opts, fn) { | |
| called = true; | |
| var socket = net.connect(opts); | |
| fn(null, socket); | |
| }); | |
| // add HTTP server "request" listener | |
| var gotReq = false; | |
| server.once('request', function(req, res) { | |
| gotReq = true; | |
| res.setHeader('X-Url', req.url); | |
| assert.equal('close', req.headers.connection); | |
| res.end(); | |
| }); | |
| var info = url.parse('http://127.0.0.1:' + port + '/bar'); | |
| info.agent = agent; | |
| http.get(info, function(res) { | |
| assert.equal('/bar', res.headers['x-url']); | |
| assert.equal('close', res.headers.connection); | |
| assert(gotReq); | |
| assert(called); | |
| done(); | |
| }); | |
| }); | |
| it('should pass through options from `http.request()`', function(done) { | |
| var agent = new Agent(function(req, opts, fn) { | |
| assert.equal('google.com', opts.host); | |
| assert.equal('bar', opts.foo); | |
| done(); | |
| }); | |
| http.get({ | |
| host: 'google.com', | |
| foo: 'bar', | |
| agent: agent | |
| }); | |
| }); | |
| it('should default to port 80', function(done) { | |
| var agent = new Agent(function(req, opts, fn) { | |
| assert.equal(80, opts.port); | |
| done(); | |
| }); | |
| // (probably) not hitting a real HTTP server here, | |
| // so no need to add a httpServer request listener | |
| http.get({ | |
| host: '127.0.0.1', | |
| path: '/foo', | |
| agent: agent | |
| }); | |
| }); | |
| it('should support the "timeout" option', function(done) { | |
| // ensure we timeout after the "error" event had a chance to trigger | |
| this.timeout(1000); | |
| this.slow(800); | |
| var agent = new Agent( | |
| function(req, opts, fn) { | |
| // this function will time out | |
| }, | |
| { timeout: 100 } | |
| ); | |
| var opts = url.parse('http://nodejs.org'); | |
| opts.agent = agent; | |
| var req = http.get(opts); | |
| req.once('error', function(err) { | |
| assert.equal('ETIMEOUT', err.code); | |
| req.abort(); | |
| done(); | |
| }); | |
| }); | |
| it('should free sockets after use', function(done) { | |
| var agent = new Agent(function(req, opts, fn) { | |
| var socket = net.connect(opts); | |
| fn(null, socket); | |
| }); | |
| // add HTTP server "request" listener | |
| var gotReq = false; | |
| server.once('request', function(req, res) { | |
| gotReq = true; | |
| res.end(); | |
| }); | |
| var info = url.parse('http://127.0.0.1:' + port + '/foo'); | |
| info.agent = agent; | |
| http.get(info, function(res) { | |
| res.socket.emit('free'); | |
| assert.equal(true, res.socket.destroyed); | |
| assert(gotReq); | |
| done(); | |
| }); | |
| }); | |
| describe('PassthroughAgent', function() { | |
| it('should pass through to `http.globalAgent`', function(done) { | |
| // add HTTP server "request" listener | |
| var gotReq = false; | |
| server.once('request', function(req, res) { | |
| gotReq = true; | |
| res.setHeader('X-Foo', 'bar'); | |
| res.setHeader('X-Url', req.url); | |
| res.end(); | |
| }); | |
| var info = url.parse('http://127.0.0.1:' + port + '/foo'); | |
| info.agent = PassthroughAgent; | |
| http.get(info, function(res) { | |
| assert.equal('bar', res.headers['x-foo']); | |
| assert.equal('/foo', res.headers['x-url']); | |
| assert(gotReq); | |
| done(); | |
| }); | |
| }); | |
| }); | |
| }); | |
| describe('"https" module', function() { | |
| var server; | |
| var port; | |
| // setup test HTTPS server | |
| before(function(done) { | |
| var options = { | |
| key: fs.readFileSync(__dirname + '/ssl-cert-snakeoil.key'), | |
| cert: fs.readFileSync(__dirname + '/ssl-cert-snakeoil.pem') | |
| }; | |
| server = https.createServer(options); | |
| server.listen(0, function() { | |
| port = server.address().port; | |
| done(); | |
| }); | |
| }); | |
| // shut down test HTTP server | |
| after(function(done) { | |
| server.once('close', function() { | |
| done(); | |
| }); | |
| server.close(); | |
| }); | |
| it('should not modify the passed in Options object', function(done) { | |
| var called = false; | |
| var agent = new Agent(function(req, opts, fn) { | |
| called = true; | |
| assert.equal(true, opts.secureEndpoint); | |
| assert.equal(443, opts.port); | |
| assert.equal('localhost', opts.host); | |
| }); | |
| var opts = { agent: agent }; | |
| var req = https.request(opts); | |
| assert.equal(true, called); | |
| assert.equal(false, 'secureEndpoint' in opts); | |
| assert.equal(false, 'port' in opts); | |
| done(); | |
| }); | |
| it('should work with a String URL', function(done) { | |
| var endpoint = 'https://127.0.0.1:' + port; | |
| var req = https.get(endpoint); | |
| // it's gonna error out since `rejectUnauthorized` is not being passed in | |
| req.on('error', function(err) { | |
| assert.equal(err.code, 'DEPTH_ZERO_SELF_SIGNED_CERT'); | |
| done(); | |
| }); | |
| }); | |
| it('should work for basic HTTPS requests', function(done) { | |
| var called = false; | |
| var agent = new Agent(function(req, opts, fn) { | |
| called = true; | |
| assert(opts.secureEndpoint); | |
| var socket = tls.connect(opts); | |
| fn(null, socket); | |
| }); | |
| // add HTTPS server "request" listener | |
| var gotReq = false; | |
| server.once('request', function(req, res) { | |
| gotReq = true; | |
| res.setHeader('X-Foo', 'bar'); | |
| res.setHeader('X-Url', req.url); | |
| res.end(); | |
| }); | |
| var info = url.parse('https://127.0.0.1:' + port + '/foo'); | |
| info.agent = agent; | |
| info.rejectUnauthorized = false; | |
| https.get(info, function(res) { | |
| assert.equal('bar', res.headers['x-foo']); | |
| assert.equal('/foo', res.headers['x-url']); | |
| assert(gotReq); | |
| assert(called); | |
| done(); | |
| }); | |
| }); | |
| it('should pass through options from `https.request()`', function(done) { | |
| var agent = new Agent(function(req, opts, fn) { | |
| assert.equal('google.com', opts.host); | |
| assert.equal('bar', opts.foo); | |
| done(); | |
| }); | |
| https.get({ | |
| host: 'google.com', | |
| foo: 'bar', | |
| agent: agent | |
| }); | |
| }); | |
| it('should support the 3-argument `https.get()`', function(done) { | |
| var agent = new Agent(function(req, opts, fn) { | |
| assert.equal('google.com', opts.host); | |
| assert.equal('/q', opts.pathname || opts.path); | |
| assert.equal('881', opts.port); | |
| assert.equal('bar', opts.foo); | |
| done(); | |
| }); | |
| https.get( | |
| 'https://google.com:881/q', | |
| { | |
| host: 'google.com', | |
| foo: 'bar', | |
| agent: agent | |
| } | |
| ); | |
| }); | |
| it('should default to port 443', function(done) { | |
| var agent = new Agent(function(req, opts, fn) { | |
| assert.equal(true, opts.secureEndpoint); | |
| assert.equal(false, opts.rejectUnauthorized); | |
| assert.equal(443, opts.port); | |
| done(); | |
| }); | |
| // (probably) not hitting a real HTTPS server here, | |
| // so no need to add a httpsServer request listener | |
| https.get({ | |
| host: '127.0.0.1', | |
| path: '/foo', | |
| agent: agent, | |
| rejectUnauthorized: false | |
| }); | |
| }); | |
| it('should not re-patch https.request', () => { | |
| var patchModulePath = "../patch-core"; | |
| var patchedRequest = https.request; | |
| delete require.cache[require.resolve(patchModulePath)]; | |
| require(patchModulePath); | |
| assert.equal(patchedRequest, https.request); | |
| assert.equal(true, https.request.__agent_base_https_request_patched__); | |
| }); | |
| describe('PassthroughAgent', function() { | |
| it('should pass through to `https.globalAgent`', function(done) { | |
| // add HTTP server "request" listener | |
| var gotReq = false; | |
| server.once('request', function(req, res) { | |
| gotReq = true; | |
| res.setHeader('X-Foo', 'bar'); | |
| res.setHeader('X-Url', req.url); | |
| res.end(); | |
| }); | |
| var info = url.parse('https://127.0.0.1:' + port + '/foo'); | |
| info.agent = PassthroughAgent; | |
| info.rejectUnauthorized = false; | |
| https.get(info, function(res) { | |
| assert.equal('bar', res.headers['x-foo']); | |
| assert.equal('/foo', res.headers['x-url']); | |
| assert(gotReq); | |
| done(); | |
| }); | |
| }); | |
| }); | |
| }); | |
| describe('"ws" server', function() { | |
| var wss; | |
| var server; | |
| var port; | |
| // setup test HTTP server | |
| before(function(done) { | |
| server = http.createServer(); | |
| wss = new WebSocket.Server({ server: server }); | |
| server.listen(0, function() { | |
| port = server.address().port; | |
| done(); | |
| }); | |
| }); | |
| // shut down test HTTP server | |
| after(function(done) { | |
| server.once('close', function() { | |
| done(); | |
| }); | |
| server.close(); | |
| }); | |
| it('should work for basic WebSocket connections', function(done) { | |
| function onconnection(ws) { | |
| ws.on('message', function(data) { | |
| assert.equal('ping', data); | |
| ws.send('pong'); | |
| }); | |
| } | |
| wss.on('connection', onconnection); | |
| var agent = new Agent(function(req, opts, fn) { | |
| var socket = net.connect(opts); | |
| fn(null, socket); | |
| }); | |
| var client = new WebSocket('ws://127.0.0.1:' + port + '/', { | |
| agent: agent | |
| }); | |
| client.on('open', function() { | |
| client.send('ping'); | |
| }); | |
| client.on('message', function(data) { | |
| assert.equal('pong', data); | |
| client.close(); | |
| wss.removeListener('connection', onconnection); | |
| done(); | |
| }); | |
| }); | |
| }); | |
| describe('"wss" server', function() { | |
| var wss; | |
| var server; | |
| var port; | |
| // setup test HTTP server | |
| before(function(done) { | |
| var options = { | |
| key: fs.readFileSync(__dirname + '/ssl-cert-snakeoil.key'), | |
| cert: fs.readFileSync(__dirname + '/ssl-cert-snakeoil.pem') | |
| }; | |
| server = https.createServer(options); | |
| wss = new WebSocket.Server({ server: server }); | |
| server.listen(0, function() { | |
| port = server.address().port; | |
| done(); | |
| }); | |
| }); | |
| // shut down test HTTP server | |
| after(function(done) { | |
| server.once('close', function() { | |
| done(); | |
| }); | |
| server.close(); | |
| }); | |
| it('should work for secure WebSocket connections', function(done) { | |
| function onconnection(ws) { | |
| ws.on('message', function(data) { | |
| assert.equal('ping', data); | |
| ws.send('pong'); | |
| }); | |
| } | |
| wss.on('connection', onconnection); | |
| var agent = new Agent(function(req, opts, fn) { | |
| var socket = tls.connect(opts); | |
| fn(null, socket); | |
| }); | |
| var client = new WebSocket('wss://127.0.0.1:' + port + '/', { | |
| agent: agent, | |
| rejectUnauthorized: false | |
| }); | |
| client.on('open', function() { | |
| client.send('ping'); | |
| }); | |
| client.on('message', function(data) { | |
| assert.equal('pong', data); | |
| client.close(); | |
| wss.removeListener('connection', onconnection); | |
| done(); | |
| }); | |
| }); | |
| }); |