rack-reverse-proxy 0.9.1 → 0.10.0

data/rack-reverse-proxy.gemspec

@@ -0,0 +1,42 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rack_reverse_proxy/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rack-reverse-proxy"
+  spec.version       = RackReverseProxy::VERSION
+
+  spec.authors = [
+    "Jon Swope",
+    "Ian Ehlert",
+    "Roman Ernst",
+    "Oleksii Fedorov"
+  ]
+
+  spec.email = [
+    "jaswope@gmail.com",
+    "ehlertij@gmail.com",
+    "rernst@farbenmeer.net",
+    "waterlink000@gmail.com"
+  ]
+
+  spec.summary       = "A Simple Reverse Proxy for Rack"
+  spec.description   = <<eos
+A Rack based reverse proxy for basic needs.
+Useful for testing or in cases where webserver configuration is unavailable.
+eos
+
+  spec.homepage      = "https://github.com/waterlink/rack-reverse-proxy"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rack", ">= 1.0.0"
+  spec.add_dependency "rack-proxy", "~> 0.5", ">= 0.5.14"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.3"
+end

data/script/rubocop

@@ -0,0 +1,5 @@
+#/usr/bin/env bash
+
+if ruby -e 'exit(1) unless RUBY_VERSION.to_f >= 2.0'; then
+  bundle exec rubocop
+fi

data/spec/rack/reverse_proxy_spec.rb

@@ -0,0 +1,586 @@
+require "spec_helper"
+
+RSpec.describe Rack::ReverseProxy do
+  include Rack::Test::Methods
+
+  def app
+    Rack::ReverseProxy.new
+  end
+
+  def dummy_app
+    lambda { |_| [200, {}, ["Dummy App"]] }
+  end
+
+  let(:http_streaming_response) do
+    double(
+      "Rack::HttpStreamingResponse",
+      :use_ssl= => nil,
+      :verify_mode= => nil,
+      :headers => {},
+      :status => 200,
+      :body => "OK"
+    )
+  end
+
+  describe "as middleware" do
+    def app
+      Rack::ReverseProxy.new(dummy_app) do
+        reverse_proxy "/test", "http://example.com/", :preserve_host => true
+        reverse_proxy "/2test", lambda { |_| "http://example.com/" }
+      end
+    end
+
+    it "forwards requests to the calling app when the path is not matched" do
+      get "/"
+      expect(last_response.body).to eq("Dummy App")
+      expect(last_response).to be_ok
+    end
+
+    it "proxies requests when a pattern is matched" do
+      stub_request(:get, "http://example.com/test").to_return(:body => "Proxied App")
+      get "/test"
+      expect(last_response.body).to eq("Proxied App")
+    end
+
+    it "produces a response header of type HeaderHash" do
+      stub_request(:get, "http://example.com/test")
+      get "/test"
+      expect(last_response.headers).to be_an_instance_of(Rack::Utils::HeaderHash)
+    end
+
+    it "parses the headers as a Hash with values of type String" do
+      stub_request(:get, "http://example.com/test").to_return(
+        :headers => { "cache-control" => "max-age=300, public" }
+      )
+      get "/test"
+      expect(last_response.headers["cache-control"]).to be_an_instance_of(String)
+      expect(last_response.headers["cache-control"]).to eq("max-age=300, public")
+    end
+
+    it "proxies requests to a lambda url when a pattern is matched" do
+      stub_request(:get, "http://example.com/2test").to_return(:body => "Proxied App2")
+      get "/2test"
+      expect(last_response.body).to eq("Proxied App2")
+    end
+
+    it "sets the Host header w/o default port" do
+      stub_request(:any, "example.com/test/stuff")
+      get "/test/stuff"
+      expect(
+        a_request(:get, "http://example.com/test/stuff").with(
+          :headers => { "Host" => "example.com" }
+        )
+      ).to have_been_made
+    end
+
+    it "sets the X-Forwarded-Host header to the proxying host by default" do
+      stub_request(:any, "example.com/test/stuff")
+      get "/test/stuff"
+      expect(
+        a_request(:get, "http://example.com/test/stuff").with(
+          :headers => { "X-Forwarded-Host" => "example.org" }
+        )
+      ).to have_been_made
+    end
+
+    it "does not produce headers with a Status key" do
+      stub_request(:get, "http://example.com/2test").to_return(
+        :status => 301, :headers => { :status => "301 Moved Permanently" }
+      )
+
+      get "/2test"
+
+      headers = last_response.headers.to_hash
+      expect(headers["Status"]).to be_nil
+    end
+
+    it "formats the headers correctly to avoid duplicates" do
+      stub_request(:get, "http://example.com/2test").to_return(
+        :headers => { :date => "Wed, 22 Jul 2015 11:27:21 GMT" }
+      )
+
+      get "/2test"
+
+      headers = last_response.headers.to_hash
+      expect(headers["Date"]).to eq("Wed, 22 Jul 2015 11:27:21 GMT")
+      expect(headers["date"]).to be_nil
+    end
+
+    it "formats the headers with dashes correctly" do
+      stub_request(:get, "http://example.com/2test").to_return(
+        :status => 301,
+        :headers => { :status => "301 Moved Permanently", :"x-additional-info" => "something" }
+      )
+
+      get "/2test"
+
+      headers = last_response.headers.to_hash
+      expect(headers["X-Additional-Info"]).to eq("something")
+      expect(headers["x-additional-info"]).to be_nil
+    end
+
+    it "the response header includes content-length" do
+      body = "this is the test body"
+      stub_request(:any, "example.com/test/stuff").to_return(
+        :body => body, :headers => { "Content-Length" => "10" }
+      )
+      get "/test/stuff"
+      expect(last_response.headers["Content-Length"]).to eq(body.length.to_s)
+    end
+
+    describe "with non-default port" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test", "http://example.com:8080/"
+        end
+      end
+
+      it "sets the Host header including non-default port" do
+        stub_request(:any, "example.com:8080/test/stuff")
+        get "/test/stuff"
+        expect(
+          a_request(:get, "http://example.com:8080/test/stuff").with(
+            :headers => { "Host" => "example.com:8080" }
+          )
+        ).to have_been_made
+      end
+    end
+
+    describe "with preserve host turned off" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test", "http://example.com/", :preserve_host => false
+        end
+      end
+
+      it "does not set the Host header" do
+        stub_request(:any, "example.com/test/stuff")
+        get "/test/stuff"
+
+        expect(
+          a_request(:get, "http://example.com/test/stuff").with(
+            :headers => { "Host" => "example.com" }
+          )
+        ).not_to have_been_made
+
+        expect(a_request(:get, "http://example.com/test/stuff")).to have_been_made
+      end
+    end
+
+    describe "with x_forwarded_host turned off" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy_options :x_forwarded_host => false
+          reverse_proxy "/test", "http://example.com/"
+        end
+      end
+
+      it "does not set the X-Forwarded-Host header to the proxying host" do
+        stub_request(:any, "example.com/test/stuff")
+        get "/test/stuff"
+        expect(
+          a_request(:get, "http://example.com/test/stuff").with(
+            :headers => { "X-Forwarded-Host" => "example.org" }
+          )
+        ).not_to have_been_made
+        expect(a_request(:get, "http://example.com/test/stuff")).to have_been_made
+      end
+    end
+
+    describe "with timeout configuration" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test/slow", "http://example.com/", :timeout => 99
+        end
+      end
+
+      it "makes request with basic auth" do
+        stub_request(:get, "http://example.com/test/slow")
+        allow(Rack::HttpStreamingResponse).to receive(:new).and_return(http_streaming_response)
+        expect(http_streaming_response).to receive(:read_timeout=).with(99)
+        get "/test/slow"
+      end
+    end
+
+    describe "without timeout configuration" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test/slow", "http://example.com/"
+        end
+      end
+
+      it "makes request with basic auth" do
+        stub_request(:get, "http://example.com/test/slow")
+        allow(Rack::HttpStreamingResponse).to receive(:new).and_return(http_streaming_response)
+        expect(http_streaming_response).not_to receive(:read_timeout=)
+        get "/test/slow"
+      end
+    end
+
+    describe "with basic auth turned on" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test", "http://example.com/", :username => "joe", :password => "shmoe"
+        end
+      end
+
+      it "makes request with basic auth" do
+        stub_request(:get, "http://joe:shmoe@example.com/test/stuff").to_return(
+          :body => "secured content"
+        )
+        get "/test/stuff"
+        expect(last_response.body).to eq("secured content")
+      end
+    end
+
+    describe "with preserve response host turned on" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test", "http://example.com/", :replace_response_host => true
+        end
+      end
+
+      it "replaces the location response header" do
+        stub_request(:get, "http://example.com/test/stuff").to_return(
+          :headers => { "location" => "http://test.com/bar" }
+        )
+        get "http://example.com/test/stuff"
+        expect(last_response.headers["location"]).to eq("http://example.com/bar")
+      end
+
+      it "keeps the port of the location" do
+        stub_request(:get, "http://example.com/test/stuff").to_return(
+          :headers => { "location" => "http://test.com/bar" }
+        )
+        get "http://example.com:3000/test/stuff"
+        expect(last_response.headers["location"]).to eq("http://example.com:3000/bar")
+      end
+
+      it "doesn't keep the port when it's default for the protocol" do
+        # webmock doesn't allow to stub an https URI, but this is enough to
+        # reply to the https code path
+        stub_request(:get, "http://example.com/test/stuff").to_return(
+          :headers => { "location" => "http://test.com/bar" }
+        )
+        get "https://example.com/test/stuff"
+        expect(last_response.headers["location"]).to eq("https://example.com/bar")
+      end
+    end
+
+    describe "with ambiguous routes and all matching" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy_options :matching => :all
+          reverse_proxy "/test", "http://example.com/"
+          reverse_proxy(%r{^/test}, "http://example.com/")
+        end
+      end
+
+      it "raises an exception" do
+        expect { get "/test" }.to raise_error(RackReverseProxy::Errors::AmbiguousMatch)
+      end
+    end
+
+    # FIXME: descriptions are not consistent with examples
+    describe "with ambiguous routes and first matching" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy_options :matching => :first
+          reverse_proxy "/test", "http://example1.com/"
+          reverse_proxy(%r{^/test}, "http://example2.com/")
+        end
+      end
+
+      it "raises an exception" do
+        stub_request(:get, "http://example1.com/test").to_return(:body => "Proxied App")
+        get "/test"
+        expect(last_response.body).to eq("Proxied App")
+      end
+    end
+
+    describe "with force ssl turned on" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test", "http://example1.com/",
+                        :force_ssl => true, :replace_response_host => true
+        end
+      end
+
+      it "redirects to the ssl version when requesting non-ssl" do
+        stub_request(:get, "http://example1.com/test/stuff").to_return(:body => "proxied")
+        get "http://example.com/test/stuff"
+        expect(last_response.headers["Location"]).to eq("https://example.com/test/stuff")
+      end
+
+      it "does nothing when already ssl" do
+        stub_request(:get, "http://example1.com/test/stuff").to_return(:body => "proxied")
+        get "https://example.com/test/stuff"
+        expect(last_response.body).to eq("proxied")
+      end
+    end
+
+    describe "with a route as a regular expression" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy %r{^/test(/.*)$}, "http://example.com$1"
+        end
+      end
+
+      it "supports subcaptures" do
+        stub_request(:get, "http://example.com/path").to_return(:body => "Proxied App")
+        get "/test/path"
+        expect(last_response.body).to eq("Proxied App")
+      end
+    end
+
+    describe "with a https route" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test", "https://example.com"
+        end
+      end
+
+      it "makes a secure request" do
+        stub_request(:get, "https://example.com/test/stuff").to_return(
+          :body => "Proxied Secure App"
+        )
+        get "/test/stuff"
+        expect(last_response.body).to eq("Proxied Secure App")
+      end
+
+      it "sets the Host header w/o default port" do
+        stub_request(:any, "https://example.com/test/stuff")
+        get "/test/stuff"
+        expect(
+          a_request(:get, "https://example.com/test/stuff").with(
+            :headers => { "Host" => "example.com" }
+          )
+        ).to have_been_made
+      end
+    end
+
+    describe "with a https route on non-default port" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test", "https://example.com:8443"
+        end
+      end
+
+      it "sets the Host header including non-default port" do
+        stub_request(:any, "https://example.com:8443/test/stuff")
+        get "/test/stuff"
+        expect(
+          a_request(:get, "https://example.com:8443/test/stuff").with(
+            :headers => { "Host" => "example.com:8443" }
+          )
+        ).to have_been_made
+      end
+    end
+
+    describe "with a route as a string" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test", "http://example.com"
+          reverse_proxy "/path", "http://example.com/foo$0"
+        end
+      end
+
+      it "appends the full path to the uri" do
+        stub_request(:get, "http://example.com/test/stuff").to_return(:body => "Proxied App")
+        get "/test/stuff"
+        expect(last_response.body).to eq("Proxied App")
+      end
+    end
+
+    describe "with a generic url" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test", "example.com"
+        end
+      end
+
+      it "throws an exception" do
+        expect { app }.to raise_error(RackReverseProxy::Errors::GenericURI)
+      end
+    end
+
+    describe "with a matching route" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy "/test", "http://example.com/"
+        end
+      end
+
+      %w(get head delete put post).each do |method|
+        describe "and using method #{method}" do
+          it "forwards the correct request" do
+            stub_request(method.to_sym, "http://example.com/test").to_return(
+              :body => "Proxied App for #{method}"
+            )
+            send(method, "/test")
+            expect(last_response.body).to eq("Proxied App for #{method}")
+          end
+
+          if %w(put post).include?(method)
+            it "forwards the request payload" do
+              stub_request(
+                method.to_sym,
+                "http://example.com/test"
+              ).to_return { |req| { :body => req.body } }
+              send(method, "/test", :test => "test")
+              expect(last_response.body).to eq("test=test")
+            end
+          end
+        end
+      end
+    end
+
+    describe "with a matching lambda" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy lambda { |path| path.match(%r{^/test}) }, "http://lambda.example.org"
+        end
+      end
+
+      it "forwards requests to the calling app when path is not matched" do
+        get "/users"
+        expect(last_response).to be_ok
+        expect(last_response.body).to eq("Dummy App")
+      end
+
+      it "proxies requests when a pattern is matched" do
+        stub_request(:get, "http://lambda.example.org/test").to_return(:body => "Proxied App")
+
+        get "/test"
+        expect(last_response.body).to eq("Proxied App")
+      end
+    end
+
+    describe "with a matching class" do
+      #:nodoc:
+      class Matcher
+        def self.match(path)
+          return unless path =~ %r{^/(test|users)}
+          Matcher.new
+        end
+
+        def url(path)
+          return "http://users-example.com" + path if path.include?("user")
+          "http://example.com" + path
+        end
+      end
+
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy Matcher
+        end
+      end
+
+      it "forwards requests to the calling app when the path is not matched" do
+        get "/"
+        expect(last_response.body).to eq("Dummy App")
+        expect(last_response).to be_ok
+      end
+
+      it "proxies requests when a pattern is matched" do
+        stub_request(:get, "http://example.com/test").to_return(:body => "Proxied App")
+        stub_request(:get, "http://users-example.com/users").to_return(:body => "User App")
+
+        get "/test"
+        expect(last_response.body).to eq("Proxied App")
+
+        get "/users"
+        expect(last_response.body).to eq("User App")
+      end
+    end
+
+    describe "with a matching class" do
+      #:nodoc:
+      class RequestMatcher
+        attr_accessor :rackreq
+
+        def initialize(rackreq)
+          self.rackreq = rackreq
+        end
+
+        def self.match(path, _headers, rackreq)
+          return nil unless path =~ %r{^/(test|users)}
+          RequestMatcher.new(rackreq)
+        end
+
+        def url(path)
+          return nil unless rackreq.params["user"] == "omer"
+          "http://users-example.com" + path
+        end
+      end
+
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy RequestMatcher
+        end
+      end
+
+      it "forwards requests to the calling app when the path is not matched" do
+        get "/"
+        expect(last_response.body).to eq("Dummy App")
+        expect(last_response).to be_ok
+      end
+
+      it "proxies requests when a pattern is matched" do
+        stub_request(:get, "http://users-example.com/users?user=omer").to_return(
+          :body => "User App"
+        )
+
+        get "/test", :user => "mark"
+        expect(last_response.body).to eq("Dummy App")
+
+        get "/users", :user => "omer"
+        expect(last_response.body).to eq("User App")
+      end
+    end
+
+    describe "with a matching class that accepts headers" do
+      #:nodoc:
+      class MatcherHeaders
+        def self.match(path, headers)
+          if path.match(%r{^/test}) && headers["ACCEPT"] && headers["ACCEPT"] == "foo.bar"
+            MatcherHeaders.new
+          end
+        end
+
+        def url(path)
+          "http://example.com" + path
+        end
+      end
+
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy MatcherHeaders, nil, :accept_headers => true
+        end
+      end
+
+      it "proxies requests when a pattern is matched and correct headers are passed" do
+        stub_request(:get, "http://example.com/test").to_return(
+          :body => "Proxied App with Headers"
+        )
+        get "/test", {}, "HTTP_ACCEPT" => "foo.bar"
+        expect(last_response.body).to eq("Proxied App with Headers")
+      end
+
+      it "does not proxy requests when a pattern is matched and incorrect headers are passed" do
+        stub_request(:get, "http://example.com/test").to_return(
+          :body => "Proxied App with Headers"
+        )
+        get "/test", {}, "HTTP_ACCEPT" => "bar.foo"
+        expect(last_response.body).not_to eq("Proxied App with Headers")
+      end
+    end
+  end
+
+  describe "as a rack app" do
+    it "responds with 404 when the path is not matched" do
+      get "/"
+      expect(last_response).to be_not_found
+    end
+  end
+end