rack-proxy 0.6.5 → 0.7.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7613a66b731bfac2c3f24a961757f359894ebdce
-  data.tar.gz: f69050ff757d137cebc48c7afcf385661e703d33
+SHA256:
+  metadata.gz: 888784aa8d1d28ae0dc2a1352aa44ba8e639d5cd604043facbb31da3fa1dc759
+  data.tar.gz: 9ba49effcffcacb930ab08fe2f6a9fd08040b60800b8aa8e5ccc274053f36c4e
 SHA512:
-  metadata.gz: 9085c724256f803ecd1d232c41ef1811c560b4600759af715e44bbd06ab343f239a5c4db7c3da6c2ede58f8089bfdd00f76cda3f509f7e65ba99e5f6d4450c68
-  data.tar.gz: e158ad03e8ff6f415d39f12759659f0148d2463d85f9734b73000401ac20b395ab7226f2cc49a5db0c69e8175f807823a9d1502a151b1aeddaaf970049190ba4
+  metadata.gz: 606ed720fb5b8c67cd1fc3058b9644e88fb2e7768d4fce4606ba0332fac24cadca11a36ab50d97cb7ff5767664864b1c1a2cf5108cd58a66fecfb3b93de37517
+  data.tar.gz: a91cc8541d7af6c390fe1c0faa3c923942a14cce746eebc3d170b95b45aafc5871a04ad1ec9fee6f0c07500534755c794f76d0c14bccdcf5fdaad06e239aeb07

data/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [ncr]

data/.travis.yml

@@ -1,4 +1,3 @@
-sudo: false
 cache: bundler
 language: ruby
 before_install:

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 gem 'rake'
 

data/Gemfile.lock

@@ -1,22 +1,22 @@
 PATH
   remote: .
   specs:
-    rack-proxy (0.6.5)
+    rack-proxy (0.7.7)
       rack
 
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
-    power_assert (0.2.6)
-    rack (2.0.3)
-    rack-test (0.5.6)
-      rack (>= 1.0)
-    rake (0.9.2.2)
-    test-unit (3.1.5)
+    power_assert (2.0.3)
+    rack (3.0.8)
+    rack-test (2.1.0)
+      rack (>= 1.3)
+    rake (13.0.6)
+    test-unit (3.6.1)
       power_assert
 
 PLATFORMS
-  ruby
+  arm64-darwin-22
 
 DEPENDENCIES
   rack-proxy!
@@ -25,4 +25,4 @@ DEPENDENCIES
   test-unit
 
 BUNDLED WITH
-   1.16.0
+   2.4.17

data/README.md

@@ -6,7 +6,7 @@ Installation
 Add the following to your `Gemfile`:
 
 ```
-gem 'rack-proxy', '~> 0.6.4'
+gem 'rack-proxy', '~> 0.7.7'
 ```
 
 Or install:
@@ -17,7 +17,8 @@ gem install rack-proxy
 
 Use Cases
 ----
-Below are some examples of real world use cases for Rack-Proxy, done something interesting add the list below and send a PR.
+
+Below are some examples of real world use cases for Rack-Proxy. If you have done something interesting, add it to the list below and send a PR.
 
 * Allowing one app to act as central trust authority
   * handle accepting self-sign certificates for internal apps
@@ -25,7 +26,7 @@ Below are some examples of real world use cases for Rack-Proxy, done something i
   * avoiding CORs complications by proxying from same domain to another backend
 * subdomain based pass-through to multiple apps
 * Complex redirect rules
-   * redirect pages with different extensions (ex: `.php`) to another app 
+   * redirect pages with different extensions (ex: `.php`) to another app
    * useful for handling awkward redirection rules for moved pages
 * fan Parallel Requests: turning a single API request to [multiple concurrent backend requests](https://github.com/typhoeus/typhoeus#making-parallel-requests) & merging results.
 * inserting or stripping headers required or problematic for certain clients
@@ -76,7 +77,7 @@ class ForwardHost < Rack::Proxy
 
     # example of inserting an additional header
     headers["X-Foo"] = "Bar"
-    
+
     # if you rewrite env, it appears that content-length isn't calculated correctly
     # resulting in only partial responses being sent to users
     # you can remove it or recalculate it here
@@ -98,14 +99,14 @@ class TrustingProxy < Rack::Proxy
   def rewrite_env(env)
     env["HTTP_HOST"] = "self-signed.badssl.com"
 
-    # We are going to trust the self-signed SSL 
+    # We are going to trust the self-signed SSL
     env["rack.ssl_verify_none"] = true
     env
   end
 
   def rewrite_response(triplet)
     status, headers, body = triplet
-    
+
     # if you rewrite env, it appears that content-length isn't calculated correctly
     # resulting in only partial responses being sent to users
     # you can remove it or recalculate it here
@@ -130,12 +131,12 @@ Test with `require 'rack_proxy_examples/example_service_proxy'`
 ```ruby
 ###
 # This is an example of how to use Rack-Proxy in a Rails application.
-#  
+#
 # Setup:
-# 1. rails new test_app 
+# 1. rails new test_app
 # 2. cd test_app
 # 3. install Rack-Proxy in `Gemfile`
-#    a. `gem 'rack-proxy', '~> 0.6.3'`
+#    a. `gem 'rack-proxy', '~> 0.7.7'`
 # 4. install gem: `bundle install`
 # 5. create `config/initializers/proxy.rb` adding this line `require 'rack_proxy_examples/example_service_proxy'`
 # 6. run: `SERVICE_URL=http://guides.rubyonrails.org rails server`
@@ -157,7 +158,7 @@ class ExampleServiceProxy < Rack::Proxy
 
         # This is the only path that needs to be set currently on Rails 5 & greater
         env['PATH_INFO'] = ENV['SERVICE_PATH'] || '/configuring.html'
-        
+
         # don't send your sites cookies to target service, unless it is a trusted internal service that can parse all your cookies
         env['HTTP_COOKIE'] = ''
         super(env)
@@ -185,14 +186,14 @@ class RackPhpProxy < Rack::Proxy
     if request.path =~ %r{\.php}
       env["HTTP_HOST"] = ENV["HTTP_HOST"] ? URI(ENV["HTTP_HOST"]).host : "localhost"
       ENV["PHP_PATH"] ||= '/manual/en/tutorial.firstpage.php'
-       
+
       # Rails 3 & 4
       env["REQUEST_PATH"] = ENV["PHP_PATH"] || "/php/#{request.fullpath}"
       # Rails 5 and above
       env['PATH_INFO'] = ENV["PHP_PATH"] || "/php/#{request.fullpath}"
 
       env['content-length'] = nil
-      
+
       super(env)
     else
       @app.call(env)
@@ -201,7 +202,7 @@ class RackPhpProxy < Rack::Proxy
 
   def rewrite_response(triplet)
     status, headers, body = triplet
-    
+
     # if you proxy depending on the backend, it appears that content-length isn't calculated correctly
     # resulting in only partial responses being sent to users
     # you can remove it or recalculate it here
@@ -232,6 +233,100 @@ This will allow to run the other requests through the application and only proxy
 
 See tests for more examples.
 
+### SSL proxy for SpringBoot applications debugging
+
+Whenever you need to debug communication with external services with HTTPS protocol (like OAuth based) you have to be able to access to your local web app through HTTPS protocol too. Typical way is to use nginx or Apache httpd as a reverse proxy but it might be inconvinuent for development environment. Simple proxy server is a better way in this case. The only what we need is to unpack incoming SSL queries and proxy them to a backend. We can prepare minimal set of files to create autonomous proxy server.
+
+Create `config.ru` file:
+```ruby
+#
+# config.ru
+#
+require 'rack'
+require 'rack-proxy'
+
+class ForwardHost < Rack::Proxy
+  def rewrite_env(env)
+    env['HTTP_X_FORWARDED_HOST'] = env['SERVER_NAME']
+    env['HTTP_X_FORWARDED_PROTO'] = env['rack.url_scheme']
+    env
+  end
+end
+
+run ForwardHost.new(backend: 'http://localhost:8080')
+```
+
+Create `Gemfile` file:
+```ruby
+source "https://rubygems.org"
+
+gem 'thin'
+gem 'rake'
+gem 'rack-proxy'
+```
+
+Create `config.yml` file with configuration of web server `thin`:
+```yml
+---
+ssl: true
+ssl-key-file: keys/domain.key
+ssl-cert-file: keys/domain.crt
+ssl-disable-verify: false
+```
+
+Create 'keys' directory and generate SSL key and certificates files `domain.key` and `domain.crt`
+
+Run `bundle exec thin start` for running it with `thin`'s default port.
+
+Or use `sudo -E thin start -C config.yml -p 443` for running with default for `https://` port.
+
+Don't forget to enable processing of `X-Forwarded-...` headers on your application side. Just add following strings to your `resources/application.yml` file.
+```yml
+---
+server:
+  tomcat:
+    remote-ip-header: x-forwarded-for
+    protocol-header:  x-forwarded-proto
+  use-forward-headers:  true
+```
+
+Add some domain name like `debug.your_app.com` into your local `/etc/hosts` file like
+```
+127.0.0.1	debug.your_app.com
+```
+
+Next start the proxy and your app. And now you can access to your Spring application through SSL connection via `https://debug.your_app.com` URI in a browser.
+
+### Using SSL/TLS certificates with HTTP connection
+This may be helpful, when third-party API has authentication by client TLS certificates and you need to proxy your requests and sign them with certificate.
+
+Just specify Rack::Proxy SSL options and your request will use TLS HTTP connection:
+```ruby
+# config.ru
+. . .
+
+cert_raw = File.read('./certs/rootCA.crt')
+key_raw = File.read('./certs/key.pem')
+
+cert = OpenSSL::X509::Certificate.new(cert_raw)
+key = OpenSSL::PKey.read(key_raw)
+
+use TLSProxy, cert: cert, key: key, use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_PEER, ssl_version: 'TLSv1_2'
+```
+
+And rewrite host for example:
+```ruby
+# tls_proxy.rb
+class TLSProxy < Rack::Proxy
+  attr_accessor :original_request, :query_params
+
+  def rewrite_env(env)
+    env["HTTP_HOST"] = "client-tls-auth-api.com:443"
+    env
+  end
+end
+```
+
 WARNING
 ----
 
@@ -242,4 +337,4 @@ Todos
 
 * Make the docs up to date with the current use case for this code: everything except streaming which involved a rather ugly monkey patch and only worked in 1.8, but does not work now.
 * Improve and validate requirements for Host and Path rewrite rules
-* Ability to inject logger and set log level
+* Ability to inject logger and set log level

data/lib/net_http_hacked.rb

@@ -4,7 +4,7 @@
 #
 # [status, headers, streamable_body]
 #
-# See http://github.com/aniero/rack-streaming-proxy
+# See http://github.com/zerowidth/rack-streaming-proxy
 # for alternative that uses additional process.
 #
 # BTW I don't like monkey patching either

data/lib/rack/http_streaming_response.rb

@@ -1,13 +1,16 @@
 require "net_http_hacked"
+require "stringio"
 
 module Rack
-
   # Wraps the hacked net/http in a Rack way.
   class HttpStreamingResponse
-    attr_accessor :use_ssl
-    attr_accessor :verify_mode
-    attr_accessor :read_timeout
-    attr_accessor :ssl_version
+    STATUSES_WITH_NO_ENTITY_BODY = {
+      204 => true,
+      205 => true,
+      304 => true
+    }.freeze
+
+    attr_accessor :use_ssl, :verify_mode, :read_timeout, :ssl_version, :cert, :key
 
     def initialize(request, host, port = nil)
       @request, @host, @port = request, host, port
@@ -18,60 +21,62 @@ module Rack
     end
 
     def code
-      response.code.to_i
+      response.code.to_i.tap do |response_code|
+        STATUSES_WITH_NO_ENTITY_BODY[response_code] && close_connection
+      end
     end
     # #status is deprecated
     alias_method :status, :code
 
     def headers
-      h = Utils::HeaderHash.new
-
-      response.to_hash.each do |k, v|
-        h[k] = v
-      end
-
-      h
+      Rack::Proxy.build_header_hash(response.to_hash)
     end
 
     # Can be called only once!
     def each(&block)
+      return if connection_closed
+
       response.read_body(&block)
     ensure
-      session.end_request_hacked
-      session.finish
+      close_connection
     end
 
     def to_s
-      @body ||= begin
-        lines = []
-
-        each do |line|
-          lines << line
-        end
-
-        lines.join
-      end
+      @to_s ||= StringIO.new.tap { |io| each { |line| io << line } }.string
     end
 
     protected
 
     # Net::HTTPResponse
     def response
-      @response ||= session.begin_request_hacked(@request)
+      @response ||= session.begin_request_hacked(request)
     end
 
     # Net::HTTP
     def session
-      @session ||= begin
-        http = Net::HTTP.new @host, @port
-        http.use_ssl = self.use_ssl
-        http.verify_mode = self.verify_mode
-        http.read_timeout = self.read_timeout
-        http.ssl_version = self.ssl_version if self.use_ssl
+      @session ||= Net::HTTP.new(host, port).tap do |http|
+        http.use_ssl = use_ssl
+        http.verify_mode = verify_mode
+        http.read_timeout = read_timeout
+        http.ssl_version = ssl_version if ssl_version
+        http.cert = cert if cert
+        http.key = key if key
         http.start
       end
     end
 
-  end
+    private
+
+    attr_reader :request, :host, :port
+
+    attr_accessor :connection_closed
 
+    def close_connection
+      return if connection_closed
+
+      session.end_request_hacked
+      session.finish
+      self.connection_closed = true
+    end
+  end
 end

data/lib/rack/proxy.rb

@@ -5,36 +5,57 @@ module Rack
 
   # Subclass and bring your own #rewrite_request and #rewrite_response
   class Proxy
-    VERSION = "0.6.5"
+    VERSION = "0.7.7".freeze
+
+    HOP_BY_HOP_HEADERS = {
+      'connection' => true,
+      'keep-alive' => true,
+      'proxy-authenticate' => true,
+      'proxy-authorization' => true,
+      'te' => true,
+      'trailer' => true,
+      'transfer-encoding' => true,
+      'upgrade' => true
+    }.freeze
 
     class << self
       def extract_http_request_headers(env)
         headers = env.reject do |k, v|
-          !(/^HTTP_[A-Z0-9_]+$/ === k) || v.nil?
+          !(/^HTTP_[A-Z0-9_\.]+$/ === k) || v.nil?
         end.map do |k, v|
           [reconstruct_header_name(k), v]
-        end.inject(Utils::HeaderHash.new) do |hash, k_v|
-          k, v = k_v
-          hash[k] = v
-          hash
-        end
+        end.then { |pairs| build_header_hash(pairs) }
 
-        x_forwarded_for = (headers["X-Forwarded-For"].to_s.split(/, +/) << env["REMOTE_ADDR"]).join(", ")
+        x_forwarded_for = (headers['X-Forwarded-For'].to_s.split(/, +/) << env['REMOTE_ADDR']).join(', ')
 
-        headers.merge!("X-Forwarded-For" =>  x_forwarded_for)
+        headers.merge!('X-Forwarded-For' => x_forwarded_for)
       end
 
       def normalize_headers(headers)
         mapped = headers.map do |k, v|
-          [k, if v.is_a? Array then v.join("\n") else v end]
+          [titleize(k), if v.is_a? Array then v.join("\n") else v end]
+        end
+        build_header_hash Hash[mapped]
+      end
+
+      def build_header_hash(pairs)
+        if Rack.const_defined?(:Headers)
+          # Rack::Headers is only available from Rack 3 onward
+          Headers.new.tap { |headers| pairs.each { |k, v| headers[k] = v } }
+        else
+          # Rack::Utils::HeaderHash is deprecated from Rack 3 onward and is to be removed in 3.1
+          Utils::HeaderHash.new(pairs)
         end
-        Utils::HeaderHash.new Hash[mapped]
       end
 
       protected
 
       def reconstruct_header_name(name)
-        name.sub(/^HTTP_/, "").gsub("_", "-")
+        titleize(name.sub(/^HTTP_/, "").gsub("_", "-"))
+      end
+
+      def titleize(str)
+        str.split("-").map(&:capitalize).join("-")
       end
     end
 
@@ -46,11 +67,20 @@ module Rack
       else
         @app = app
       end
+
       @streaming = opts.fetch(:streaming, true)
       @ssl_verify_none = opts.fetch(:ssl_verify_none, false)
-      @backend = URI(opts[:backend]) if opts[:backend]
+      @backend = opts[:backend] ? URI(opts[:backend]) : nil
       @read_timeout = opts.fetch(:read_timeout, 60)
-      @ssl_version = opts[:ssl_version] if opts[:ssl_version]
+      @ssl_version = opts[:ssl_version]
+      @cert = opts[:cert]
+      @key = opts[:key]
+      @verify_mode = opts[:verify_mode]
+
+      @username = opts[:username]
+      @password = opts[:password]
+
+      @opts = opts
     end
 
     def call(env)
@@ -79,7 +109,7 @@ module Rack
         full_path = source_request.fullpath
       end
 
-      target_request = Net::HTTP.const_get(source_request.request_method.capitalize).new(full_path)
+      target_request = Net::HTTP.const_get(source_request.request_method.capitalize, false).new(full_path)
 
       # Setup headers
       target_request.initialize_http_header(self.class.extract_http_request_headers(source_request.env))
@@ -92,9 +122,11 @@ module Rack
         target_request.body_stream.rewind
       end
 
+      # Use basic auth if we have to
+      target_request.basic_auth(@username, @password) if @username && @password
+
       backend = env.delete('rack.backend') || @backend || source_request
-      use_ssl = backend.scheme == "https"
-      ssl_verify_none = (env.delete('rack.ssl_verify_none') || @ssl_verify_none) == true
+      use_ssl = backend.scheme == "https" || @cert
       read_timeout = env.delete('http.read_timeout') || @read_timeout
 
       # Create the response
@@ -103,30 +135,34 @@ module Rack
         target_response = HttpStreamingResponse.new(target_request, backend.host, backend.port)
         target_response.use_ssl = use_ssl
         target_response.read_timeout = read_timeout
-        target_response.verify_mode = OpenSSL::SSL::VERIFY_NONE if use_ssl && ssl_verify_none
         target_response.ssl_version = @ssl_version if @ssl_version
+        target_response.verify_mode = (@verify_mode || OpenSSL::SSL::VERIFY_NONE) if use_ssl
+        target_response.cert = @cert if @cert
+        target_response.key = @key if @key
       else
         http = Net::HTTP.new(backend.host, backend.port)
         http.use_ssl = use_ssl if use_ssl
         http.read_timeout = read_timeout
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if use_ssl && ssl_verify_none
         http.ssl_version = @ssl_version if @ssl_version
+        http.verify_mode = (@verify_mode || OpenSSL::SSL::VERIFY_NONE if use_ssl) if use_ssl
+        http.cert = @cert if @cert
+        http.key = @key if @key
 
         target_response = http.start do
           http.request(target_request)
         end
       end
 
+      code    = target_response.code
       headers = self.class.normalize_headers(target_response.respond_to?(:headers) ? target_response.headers : target_response.to_hash)
       body    = target_response.body || [""]
       body    = [body] unless body.respond_to?(:each)
 
       # According to https://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-14#section-7.1.3.1Acc
       # should remove hop-by-hop header fields
-      headers.reject! { |k| ['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade'].include? k.downcase }
-      [target_response.code, headers, body]
-    end
+      headers.reject! { |k| HOP_BY_HOP_HEADERS[k.downcase] }
 
+      [code, headers, body]
+    end
   end
-
 end

data/lib/rack_proxy_examples/example_service_proxy.rb

@@ -1,11 +1,11 @@
 ###
 # This is an example of how to use Rack-Proxy in a Rails application.
-#  
+#
 # Setup:
-# 1. rails new test_app 
+# 1. rails new test_app
 # 2. cd test_app
 # 3. install Rack-Proxy in `Gemfile`
-#    a. `gem 'rack-proxy', '~> 0.6.3'`
+#    a. `gem 'rack-proxy', '~> 0.7.7'`
 # 4. install gem: `bundle install`
 # 5. create `config/initializers/proxy.rb` adding this line `require 'rack_proxy_examples/example_service_proxy'`
 # 6. run: `SERVICE_URL=http://guides.rubyonrails.org rails server`
@@ -27,7 +27,7 @@ class ExampleServiceProxy < Rack::Proxy
 
         # This is the only path that needs to be set currently on Rails 5 & greater
         env['PATH_INFO'] = ENV['SERVICE_PATH'] || '/configuring.html'
-        
+
         # don't send your sites cookies to target service, unless it is a trusted internal service that can parse all your cookies
         env['HTTP_COOKIE'] = ''
         super(env)

data/rack-proxy.gemspec

@@ -6,13 +6,13 @@ Gem::Specification.new do |s|
   s.name        = "rack-proxy"
   s.version     = Rack::Proxy::VERSION
   s.platform    = Gem::Platform::RUBY
+  s.license     = 'MIT'
   s.authors     = ["Jacek Becela"]
   s.email       = ["jacek.becela@gmail.com"]
   s.homepage    = "https://github.com/ncr/rack-proxy"
   s.summary     = %q{A request/response rewriting HTTP proxy. A Rack app.}
   s.description = %q{A Rack app that provides request/response rewriting proxy capabilities with streaming.}
-
-  s.rubyforge_project = "rack-proxy"
+  s.required_ruby_version = '>= 2.6'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/test/http_streaming_response_test.rb

@@ -4,23 +4,24 @@ require "rack/http_streaming_response"
 class HttpStreamingResponseTest < Test::Unit::TestCase
 
   def setup
-    host, req = "www.trix.pl", Net::HTTP::Get.new("/")
-    @response = Rack::HttpStreamingResponse.new(req, host)
+    host, req = "example.com", Net::HTTP::Get.new("/")
+    @response = Rack::HttpStreamingResponse.new(req, host, 443)
+    @response.use_ssl = true
   end
 
   def test_streaming
     # Response status
-    assert @response.code == 200
-    assert @response.status == 200
+    assert_equal 200, @response.status
+    assert_equal 200, @response.status
 
     # Headers
     headers = @response.headers
 
-    assert headers.size > 0
+    assert headers.size.positive?
 
-    assert headers["content-type"] == ["text/html;charset=utf-8"]
-    assert headers["CoNtEnT-TyPe"] == headers["content-type"]
-    assert headers["content-length"].first.to_i > 0
+    assert_match %r{text/html; ?charset=utf-8}, headers["content-type"].first.downcase
+    assert_equal headers["content-type"], headers["CoNtEnT-TyPe"]
+    assert headers["content-length"].first.to_i.positive?
 
     # Body
     chunks = []
@@ -28,7 +29,7 @@ class HttpStreamingResponseTest < Test::Unit::TestCase
       chunks << chunk
     end
 
-    assert chunks.size > 0
+    assert chunks.size.positive?
     chunks.each do |chunk|
       assert chunk.is_a?(String)
     end
@@ -36,7 +37,7 @@ class HttpStreamingResponseTest < Test::Unit::TestCase
   end
 
   def test_to_s
-    assert_equal @response.headers["Content-Length"].first.to_i, @response.body.to_s.size
+    assert_equal @response.headers["Content-Length"].first.to_i, @response.body.to_s.bytesize
   end
 
   def test_to_s_called_twice

data/test/rack_proxy_test.rb

@@ -6,7 +6,7 @@ class RackProxyTest < Test::Unit::TestCase
     attr_accessor :host
 
     def rewrite_env(env)
-      env["HTTP_HOST"] = self.host || 'www.trix.pl'
+      env["HTTP_HOST"] = self.host || 'example.com'
       env
     end
   end
@@ -18,14 +18,15 @@ class RackProxyTest < Test::Unit::TestCase
   def test_http_streaming
     get "/"
     assert last_response.ok?
-    assert_match(/Jacek Becela/, last_response.body)
+
+    assert_match(/Example Domain/, last_response.body)
   end
 
   def test_http_full_request
     app(:streaming => false)
     get "/"
     assert last_response.ok?
-    assert_match(/Jacek Becela/, last_response.body)
+    assert_match(/Example Domain/, last_response.body)
   end
 
   def test_http_full_request_headers
@@ -77,10 +78,10 @@ class RackProxyTest < Test::Unit::TestCase
     proxy_class = Rack::Proxy
 
     header = proxy_class.send(:reconstruct_header_name, "HTTP_ABC")
-    assert header == "ABC"
+    assert header == "Abc"
 
     header = proxy_class.send(:reconstruct_header_name, "HTTP_ABC_D")
-    assert header == "ABC-D"
+    assert header == "Abc-D"
   end
 
   def test_extract_http_request_headers
@@ -89,12 +90,14 @@ class RackProxyTest < Test::Unit::TestCase
       'NOT-HTTP-HEADER' => 'test-value',
       'HTTP_ACCEPT' => 'text/html',
       'HTTP_CONNECTION' => nil,
-      'HTTP_CONTENT_MD5' => 'deadbeef'
+      'HTTP_CONTENT_MD5' => 'deadbeef',
+      'HTTP_HEADER.WITH.PERIODS' => 'stillmooing'
     }
 
     headers = proxy_class.extract_http_request_headers(env)
     assert headers.key?('ACCEPT')
     assert headers.key?('CONTENT-MD5')
+    assert headers.key?('HEADER.WITH.PERIODS')
     assert !headers.key?('CONNECTION')
     assert !headers.key?('NOT-HTTP-HEADER')
   end
@@ -117,7 +120,7 @@ class RackProxyTest < Test::Unit::TestCase
   end
 
   def test_response_header_included_Hop_by_hop
-    app({:streaming => true}).host = 'auth.goeasyship.com'
+    app({:streaming => true}).host = 'mockapi.io'
     get 'https://example.com/oauth2/token/info?access_token=123'
     assert !last_response.headers.key?('transfer-encoding')
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-proxy
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.7
 platform: ruby
 authors:
 - Jacek Becela
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-09-17 00:00:00.000000000 Z
+date: 2023-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -60,6 +60,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/FUNDING.yml"
 - ".gitignore"
 - ".travis.yml"
 - Gemfile
@@ -81,9 +82,10 @@ files:
 - test/rack_proxy_test.rb
 - test/test_helper.rb
 homepage: https://github.com/ncr/rack-proxy
-licenses: []
+licenses:
+- MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -91,16 +93,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: rack-proxy
-rubygems_version: 2.6.13
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: A request/response rewriting HTTP proxy. A Rack app.
 test_files: