src/cobalt/debug/remote/devtools/node_modules/agent-base/test/test.js - cobalt - Git at Google

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