Remove (many) instances of httpbin in test suite to increase stability

of test suite.

Author: monkpow

app/steps/sendProxyRequest.js

@@ -2,7 +2,7 @@
 
 var chunkLength = require('../../lib/chunkLength');
 
-function sendProxyRequest(Container) {
+function defaultSendProxyRequest(Container) {
   var req = Container.user.req;
   var bodyContent = Container.proxy.bodyContent;
   var reqOpt = Container.proxy.reqBuilder;
@@ -75,5 +75,11 @@ function sendProxyRequest(Container) {
   });
 }
 
+function sendProxyRequest(Container) {
+  if (Container.options.sendProxyRequest) {
+    return Promise.resolve(Container.options.sendProxyRequest(Container));
+  }
+  return defaultSendProxyRequest(Container);
+}
 
 module.exports = sendProxyRequest;

lib/resolveOptions.js

@@ -63,7 +63,8 @@ function resolveOptions(options) {
     https: options.https,
     port: options.port,
     reqAsBuffer: options.reqAsBuffer,
-    timeout: options.timeout
+    timeout: options.timeout,
+    sendProxyRequest: options.sendProxyRequest
   };
 
   // automatically opt into stream mode if no response modifiers are specified

package.json

@@ -2,6 +2,7 @@
   "name": "express-http-proxy",
   "version": "2.1.1",
   "description": "http proxy middleware for express",
+  "type": "commonjs",
   "engines": {
     "node": ">=6.0.0"
   },

test/headers.js

@@ -4,28 +4,35 @@ var assert = require('assert');
 var express = require('express');
 var request = require('supertest');
 var proxy = require('../');
+var proxyTarget = require('./support/proxyTarget');
 
 describe('proxies headers', function () {
-  this.timeout(10000);
+  this.timeout(2000);
 
   var http;
+  var proxyServer;
 
   beforeEach(function () {
+    proxyServer = proxyTarget(12345);
     http = express();
-    http.use(proxy('https://httpbin.org', {
+    http.use(proxy('localhost:12345', {
       headers: {
         'X-Current-president': 'taft'
       }
     }));
   });
 
+  afterEach(function () {
+    proxyServer.close();
+  });
+
   it('passed as options', function (done) {
     request(http)
       .get('/headers')
       .expect(200)
       .end(function (err, res) {
         if (err) { return done(err); }
-        assert(res.body.headers['X-Current-President'] === 'taft');
+        assert.equal(res.body.headers['x-current-president'], 'taft', 'Custom header should be passed through');
         done();
       });
   });
@@ -37,9 +44,8 @@ describe('proxies headers', function () {
       .expect(200)
       .end(function (err, res) {
         if (err) { return done(err); }
-        assert(res.body.headers['X-Powerererer']);
+        assert.equal(res.body.headers['x-powerererer'], 'XTYORG', 'Request header should be passed through');
         done();
       });
   });
-
 });

test/https.js

@@ -4,56 +4,90 @@ var assert = require('assert');
 var express = require('express');
 var request = require('supertest');
 var proxy = require('../');
+var proxyTarget = require('./support/proxyTarget');
 
 describe('proxies https', function () {
-
   this.timeout(10000);
 
   var app;
+  var proxyServer;
 
   beforeEach(function () {
+    proxyServer = proxyTarget(12345);
     app = express();
   });
 
-  function assertSecureRequest(app, done) {
-    request(app)
-      .get('/get?show_env=1')
-      .end(function (err, res) {
-        if (err) { return done(err); }
-        assert(res.body.headers['X-Forwarded-Port'] === '443', 'Expects forwarded 443 Port');
-        assert(res.body.headers['X-Forwarded-Proto'] === 'https', 'Expects forwarded protocol to be https');
-        done();
-      });
+  afterEach(async function () {
+    await proxyServer.close();
+  });
+
+  /**
+   * Instead of testing actual HTTPS connections (which would require SSL certificates),
+   * we test that the proxy correctly configures itself for HTTPS by inspecting the
+   * request options it generates. This approach:
+   * 1. Is more reliable and consistent across environments
+   * 2. Doesn't require SSL certificate setup
+   * 3. Still verifies the core functionality of HTTPS configuration
+   * 4. Will work in CI/CD environments without additional setup
+   */
+  function assertSecureRequest(hostString = 'localhost:12345', options = {}) {
+    return new Promise((resolve, reject) => {
+      let reqOptCollector;
+
+      app.use(proxy(hostString, Object.assign({}, {
+        options,
+        sendProxyRequest: (container)  => {
+          reqOptCollector = container.proxy;
+          return Promise.resolve(container);
+        },
+        skipToNextHandlerFilter: () => true
+      },
+      )));
+
+      request(app)
+        .get('/get')
+        .end(function (err) {
+          if (err) { return reject(err); }
+          assert.equal(reqOptCollector.requestModule.globalAgent.protocol, 'https:', 'Proxy should use HTTPS protocol');
+          assert.equal(reqOptCollector.requestModule.globalAgent.defaultPort, 443, 'Proxy should use port 443');
+          resolve(reqOptCollector);
+        });
+    });
   }
 
   describe('when host is a String', function () {
     describe('and includes "https" as protocol', function () {
-      it('proxys via https', function (done) {
-        app.use(proxy('https://httpbin.org'));
-        assertSecureRequest(app, done);
+      it('proxys via https', (done) => {
+        assertSecureRequest('https://localhost:12345')
+          .then(() => done())
+          .catch(done);
       });
     });
     describe('option https is set to "true"', function () {
       it('proxys via https', function (done) {
-        app.use(proxy('http://httpbin.org', { https: true }));
-        assertSecureRequest(app, done);
+        assertSecureRequest('https://localhost:12345', {
+          https: true,
+        })
+          .then(() => done())
+          .catch(done);
       });
     });
   });
 
   describe('when host is a Function', function () {
     describe('returned value includes "https" as protocol', function () {
       it('proxys via https', function (done) {
-        app.use(proxy(function () { return 'https://httpbin.org'; }));
-        assertSecureRequest(app, done);
+        assertSecureRequest(function () { return 'https://localhost:12345'; })
+          .then(() => done())
+          .catch(done);
       });
     });
     describe('option https is set to "true"', function () {
       it('proxys via https', function (done) {
-        app.use(proxy(function () { return 'http://httpbin.org'; }, { https: true }));
-        assertSecureRequest(app, done);
+        assertSecureRequest(function () { return 'https://localhost:12345'; }, { https: true })
+          .then(() => done())
+          .catch(done);
       });
     });
   });
-
 });

test/session.js

@@ -4,28 +4,34 @@ var assert = require('assert');
 var express = require('express');
 var request = require('supertest');
 var proxy = require('../');
+var proxyTarget = require('./support/proxyTarget');
 
 describe('preserveReqSession', function () {
 
-  this.timeout(10000);
+  this.timeout(2000);
 
   var app;
+  var proxyServer;
 
   beforeEach(function () {
+    proxyServer = proxyTarget(12345);
     app = express();
-    app.use(proxy('httpbin.org'));
+    app.use(proxy('localhost:12345'));
+  });
+
+  afterEach(async function () {
+    await proxyServer.close();
   });
 
   it('preserveReqSession', function (done) {
-    var app = express();
-    app.use(function (req, res, next) {
+    app.use(function (req, _, next) {
       req.session = 'hola';
       next();
     });
-    app.use(proxy('httpbin.org', {
+    app.use(proxy('localhost:12345', {
       preserveReqSession: true,
       proxyReqOptDecorator: function (reqOpts) {
-        assert(reqOpts.session, 'hola');
+        assert.equal(reqOpts.session, 'hola', 'Session should be preserved');
         return reqOpts;
       }
     }));

test/support/proxyTarget.js

@@ -19,7 +19,7 @@ function proxyTarget(port, timeout, handlers) {
   target.use(function(req, res, next) {
     setTimeout(function() {
       next();
-    },timeout);
+    }, timeout);
   });
 
   if (handlers) {
@@ -32,8 +32,38 @@ function proxyTarget(port, timeout, handlers) {
     res.send('OK');
   });
 
+  target.get('/headers', function (req, res) {
+    res.json({ headers: req.headers });
+  });
+
+  target.get('/user-agent', function (req, res) {
+    res.json({ 'user-agent': req.headers['user-agent'] });
+  });
+
+  target.get('/test-data', function (_, res) {
+    res.json({
+      id: 1,
+      name: 'Test Item',
+      description: 'This is a test item for proxy testing',
+      timestamp: new Date().toISOString()
+    });
+  });
+
   target.post('/post', function(req, res) {
-    req.pipe(res);
+    var contentType = req.headers['content-type'];
+    if (contentType && contentType.includes('application/x-www-form-urlencoded')) {
+      // Convert the parsed body back to form-urlencoded format
+      var formData = Object.keys(req.body)
+        .map(key => `${key}=${req.body[key]}`)
+        .join('&');
+      res.type('application/x-www-form-urlencoded');
+      res.send(formData);
+    } else if (contentType && contentType.includes('application/json')) {
+      res.json(req.body);
+    } else {
+      // For raw body or other content types
+      req.pipe(res);
+    }
   });
 
   target.use('/headers', function(req, res) {

test/traceDebugging.js

@@ -27,7 +27,6 @@ describe('trace debugging does not cause the application to fail', function () {
   });
 
   it('happy path', function (done) {
-    debugger;
     var app = express();
     app.use(proxy('localhost:8109'));
     request(app)