/**
 * Module dependencies.
 */

let fs = require('fs');
let url = require('url');
let http = require('http');
let https = require('https');
let assert = require('assert');
let Proxy = require('proxy');
let HttpsProxyAgent = require('../');

describe('HttpsProxyAgent', function() {
	let server;
	let serverPort;

	let sslServer;
	let sslServerPort;

	let proxy;
	let proxyPort;

	let sslProxy;
	let sslProxyPort;

	before(function(done) {
		// setup target HTTP server
		server = http.createServer();
		server.listen(function() {
			serverPort = server.address().port;
			done();
		});
	});

	before(function(done) {
		// setup HTTP proxy server
		proxy = Proxy();
		proxy.listen(function() {
			proxyPort = proxy.address().port;
			done();
		});
	});

	before(function(done) {
		// setup target HTTPS server
		let options = {
			key: fs.readFileSync(`${__dirname}/ssl-cert-snakeoil.key`),
			cert: fs.readFileSync(`${__dirname}/ssl-cert-snakeoil.pem`)
		};
		sslServer = https.createServer(options);
		sslServer.listen(function() {
			sslServerPort = sslServer.address().port;
			done();
		});
	});

	before(function(done) {
		// setup SSL HTTP proxy server
		let options = {
			key: fs.readFileSync(`${__dirname}/ssl-cert-snakeoil.key`),
			cert: fs.readFileSync(`${__dirname}/ssl-cert-snakeoil.pem`)
		};
		sslProxy = Proxy(https.createServer(options));
		sslProxy.listen(function() {
			sslProxyPort = sslProxy.address().port;
			done();
		});
	});

	// shut down test HTTP server
	after(function(done) {
		server.once('close', function() {
			done();
		});
		server.close();
	});

	after(function(done) {
		proxy.once('close', function() {
			done();
		});
		proxy.close();
	});

	after(function(done) {
		sslServer.once('close', function() {
			done();
		});
		sslServer.close();
	});

	after(function(done) {
		sslProxy.once('close', function() {
			done();
		});
		sslProxy.close();
	});

	describe('constructor', function() {
		it('should throw an Error if no "proxy" argument is given', function() {
			assert.throws(function() {
				new HttpsProxyAgent();
			});
		});
		it('should accept a "string" proxy argument', function() {
			let agent = new HttpsProxyAgent(`http://localhost:${proxyPort}`);
			assert.equal('localhost', agent.proxy.host);
			assert.equal(proxyPort, agent.proxy.port);
		});
		it('should accept a `url.parse()` result object argument', function() {
			let opts = url.parse(`http://localhost:${proxyPort}`);
			let agent = new HttpsProxyAgent(opts);
			assert.equal('localhost', agent.proxy.host);
			assert.equal(proxyPort, agent.proxy.port);
		});
		describe('secureProxy', function() {
			it('should default to `false`', function() {
				let agent = new HttpsProxyAgent({ port: proxyPort });
				assert.equal(false, agent.secureProxy);
			});
			it('should be `false` when "http:" protocol is used', function() {
				let agent = new HttpsProxyAgent({
					port: proxyPort,
					protocol: 'http:'
				});
				assert.equal(false, agent.secureProxy);
			});
			it('should be `true` when "https:" protocol is used', function() {
				let agent = new HttpsProxyAgent({
					port: proxyPort,
					protocol: 'https:'
				});
				assert.equal(true, agent.secureProxy);
			});
			it('should be `true` when "https" protocol is used', function() {
				let agent = new HttpsProxyAgent({
					port: proxyPort,
					protocol: 'https'
				});
				assert.equal(true, agent.secureProxy);
			});
		});
	});

	describe('"http" module', function() {
		beforeEach(function() {
			delete proxy.authenticate;
		});

		it('should work over an HTTP proxy', function(done) {
			server.once('request', function(req, res) {
				res.end(JSON.stringify(req.headers));
			});

			let proxy =
				process.env.HTTP_PROXY ||
				process.env.http_proxy ||
				`http://localhost:${proxyPort}`;
			let agent = new HttpsProxyAgent(proxy);

			let opts = url.parse(`http://localhost:${serverPort}`);
			opts.agent = agent;

			let req = http.get(opts, function(res) {
				let data = '';
				res.setEncoding('utf8');
				res.on('data', function(b) {
					data += b;
				});
				res.on('end', function() {
					data = JSON.parse(data);
					assert.equal(`localhost:${serverPort}`, data.host);
					done();
				});
			});
			req.once('error', done);
		});
		it('should work over an HTTPS proxy', function(done) {
			server.once('request', function(req, res) {
				res.end(JSON.stringify(req.headers));
			});

			let proxy =
				process.env.HTTPS_PROXY ||
				process.env.https_proxy ||
				`https://localhost:${sslProxyPort}`;
			proxy = url.parse(proxy);
			proxy.rejectUnauthorized = false;
			let agent = new HttpsProxyAgent(proxy);

			let opts = url.parse(`http://localhost:${serverPort}`);
			opts.agent = agent;

			http.get(opts, function(res) {
				let data = '';
				res.setEncoding('utf8');
				res.on('data', function(b) {
					data += b;
				});
				res.on('end', function() {
					data = JSON.parse(data);
					assert.equal(`localhost:${serverPort}`, data.host);
					done();
				});
			});
		});
		it('should receive the 407 authorization code on the `http.ClientResponse`', function(done) {
			// set a proxy authentication function for this test
			proxy.authenticate = function(req, fn) {
				// reject all requests
				fn(null, false);
			};

			let proxyUri =
				process.env.HTTP_PROXY ||
				process.env.http_proxy ||
				`http://localhost:${proxyPort}`;
			let agent = new HttpsProxyAgent(proxyUri);

			let opts = {};
			// `host` and `port` don't really matter since the proxy will reject anyways
			opts.host = 'localhost';
			opts.port = 80;
			opts.agent = agent;

			let req = http.get(opts, function(res) {
				assert.equal(407, res.statusCode);
				assert('proxy-authenticate' in res.headers);
				done();
			});
		});
		it('should not error if the proxy responds with 407 and the request is aborted', function(done) {
			proxy.authenticate = function(req, fn) {
				fn(null, false);
			};

			const proxyUri =
				process.env.HTTP_PROXY ||
				process.env.http_proxy ||
				`http://localhost:${proxyPort}`;

			const req = http.get(
				{
					agent: new HttpsProxyAgent(proxyUri)
				},
				function(res) {
					assert.equal(407, res.statusCode);
					req.abort();
				}
			);

			req.on('abort', done);
		});
		it('should emit an "end" event on the `http.IncomingMessage` if the proxy responds with non-200 status code', function(done) {
			proxy.authenticate = function(req, fn) {
				fn(null, false);
			};

			const proxyUri =
				process.env.HTTP_PROXY ||
				process.env.http_proxy ||
				`http://localhost:${proxyPort}`;

			const req = http.get(
				{
					agent: new HttpsProxyAgent(proxyUri)
				},
				function(res) {
					assert.equal(407, res.statusCode);

					res.resume();
					res.on('end', done);
				}
			);
		});
		it('should emit an "error" event on the `http.ClientRequest` if the proxy does not exist', function(done) {
			// port 4 is a reserved, but "unassigned" port
			let proxyUri = 'http://localhost:4';
			let agent = new HttpsProxyAgent(proxyUri);

			let opts = url.parse('http://nodejs.org');
			opts.agent = agent;

			let req = http.get(opts);
			req.once('error', function(err) {
				assert.equal('ECONNREFUSED', err.code);
				req.abort();
				done();
			});
		});

		it('should allow custom proxy "headers"', function(done) {
			server.once('connect', function(req, socket, head) {
				assert.equal('CONNECT', req.method);
				assert.equal('bar', req.headers.foo);
				socket.destroy();
				done();
			});

			let uri = `http://localhost:${serverPort}`;
			let proxyOpts = url.parse(uri);
			proxyOpts.headers = {
				Foo: 'bar'
			};
			let agent = new HttpsProxyAgent(proxyOpts);

			let opts = {};
			// `host` and `port` don't really matter since the proxy will reject anyways
			opts.host = 'localhost';
			opts.port = 80;
			opts.agent = agent;

			http.get(opts);
		});
	});

	describe('"https" module', function() {
		it('should work over an HTTP proxy', function(done) {
			sslServer.once('request', function(req, res) {
				res.end(JSON.stringify(req.headers));
			});

			let proxy =
				process.env.HTTP_PROXY ||
				process.env.http_proxy ||
				`http://localhost:${proxyPort}`;
			let agent = new HttpsProxyAgent(proxy);

			let opts = url.parse(`https://localhost:${sslServerPort}`);
			opts.rejectUnauthorized = false;
			opts.agent = agent;

			https.get(opts, function(res) {
				let data = '';
				res.setEncoding('utf8');
				res.on('data', function(b) {
					data += b;
				});
				res.on('end', function() {
					data = JSON.parse(data);
					assert.equal(`localhost:${sslServerPort}`, data.host);
					done();
				});
			});
		});

		it('should work over an HTTPS proxy', function(done) {
			sslServer.once('request', function(req, res) {
				res.end(JSON.stringify(req.headers));
			});

			let proxy =
				process.env.HTTPS_PROXY ||
				process.env.https_proxy ||
				`https://localhost:${sslProxyPort}`;
			proxy = url.parse(proxy);
			proxy.rejectUnauthorized = false;
			let agent = new HttpsProxyAgent(proxy);

			let opts = url.parse(`https://localhost:${sslServerPort}`);
			opts.agent = agent;
			opts.rejectUnauthorized = false;

			https.get(opts, function(res) {
				let data = '';
				res.setEncoding('utf8');
				res.on('data', function(b) {
					data += b;
				});
				res.on('end', function() {
					data = JSON.parse(data);
					assert.equal(`localhost:${sslServerPort}`, data.host);
					done();
				});
			});
		});

		it('should not send a port number for the default port', function(done) {
			sslServer.once('request', function(req, res) {
				res.end(JSON.stringify(req.headers));
			});

			let proxy =
				process.env.HTTPS_PROXY ||
				process.env.https_proxy ||
				`https://localhost:${sslProxyPort}`;
			proxy = url.parse(proxy);
			proxy.rejectUnauthorized = false;
			let agent = new HttpsProxyAgent(proxy);
			agent.defaultPort = sslServerPort;

			let opts = url.parse(`https://localhost:${sslServerPort}`);
			opts.agent = agent;
			opts.rejectUnauthorized = false;

			https.get(opts, function(res) {
				let data = '';
				res.setEncoding('utf8');
				res.on('data', function(b) {
					data += b;
				});
				res.on('end', function() {
					data = JSON.parse(data);
					assert.equal('localhost', data.host);
					done();
				});
			});
		});
	});
});