puffing-billy 0.4.1 → 0.5.0

data/lib/billy/handlers/request_handler.rb

@@ -6,9 +6,9 @@ module Billy
     def_delegators :stub_handler, :stub
 
     def handlers
-      @handlers ||= { :stubs => StubHandler.new,
-                      :cache => CacheHandler.new,
-                      :proxy => ProxyHandler.new }
+      @handlers ||= { stubs: StubHandler.new,
+                      cache: CacheHandler.new,
+                      proxy: ProxyHandler.new }
     end
 
     def handle_request(method, url, headers, body)
@@ -20,7 +20,7 @@ module Billy
       end
 
       body_msg = method == 'post' ? " with body '#{body}'" : ''
-      { :error => "Connection to #{url}#{body_msg} not cached and new http connections are disabled" }
+      { error: "Connection to #{url}#{body_msg} not cached and new http connections are disabled" }
     end
 
     def handles_request?(method, url, headers, body)
@@ -32,9 +32,7 @@ module Billy
     end
 
     def reset
-      handlers.each_value do |handler|
-        handler.reset
-      end
+      handlers.each_value(&:reset)
     end
 
     def reset_stubs
@@ -46,7 +44,7 @@ module Billy
     end
 
     def restore_cache
-      warn "[DEPRECATION] `restore_cache` is deprecated as cache files are dynamically checked. Use `reset_cache` if you just want to clear the cache."
+      warn '[DEPRECATION] `restore_cache` is deprecated as cache files are dynamically checked. Use `reset_cache` if you just want to clear the cache.'
       reset_cache
     end
 

data/lib/billy/handlers/stub_handler.rb

@@ -8,7 +8,7 @@ module Billy
     def handle_request(method, url, headers, body)
       if handles_request?(method, url, headers, body)
         if (stub = find_stub(method, url))
-          query_string = Addressable::URI.parse(url).query || ""
+          query_string = Addressable::URI.parse(url).query || ''
           params = CGI.parse(query_string)
           stub.call(params, headers, body).tap do |response|
             Billy.log(:info, "puffing-billy: STUB #{method} for '#{url}'")
@@ -20,7 +20,7 @@ module Billy
       nil
     end
 
-    def handles_request?(method, url, headers, body)
+    def handles_request?(method, url, _headers, _body)
       !find_stub(method, url).nil?
     end
 

data/lib/billy/json_utils.rb

@@ -2,7 +2,6 @@ require 'json'
 
 module Billy
   module JSONUtils
-
     def self.json?(value)
       !!JSON.parse(value)
     rescue JSON::ParserError, TypeError
@@ -33,7 +32,7 @@ module Billy
     #   Processing JSON in this way enables a consistent SHA to be derived from
     #   JSON payloads which have the same name/value pairs, but different orders.
     def self.sort_json(json_str)
-      JSONUtils::sort_hash_keys(JSON.parse(json_str, symbolize_names: true)).to_json
+      JSONUtils.sort_hash_keys(JSON.parse(json_str, symbolize_names: true)).to_json
     end
   end
 end

data/lib/billy/proxy_connection.rb

@@ -37,7 +37,7 @@ module Billy
       else
         if @ssl
           uri = Addressable::URI.parse(@parser.request_url)
-          @url = "https://#{@ssl}#{[uri.path,uri.query].compact.join('?')}"
+          @url = "https://#{@ssl}#{[uri.path, uri.query].compact.join('?')}"
         else
           @url = @parser.request_url
         end
@@ -52,17 +52,17 @@ module Billy
       @parser = Http::Parser.new(self)
       send_data("HTTP/1.0 200 Connection established\r\nProxy-agent: Puffing-Billy/0.0.0\r\n\r\n")
       start_tls(
-        :private_key_file => File.expand_path('../mitm.key', __FILE__),
-        :cert_chain_file => File.expand_path('../mitm.crt', __FILE__)
+        private_key_file: File.expand_path('../mitm.key', __FILE__),
+        cert_chain_file: File.expand_path('../mitm.crt', __FILE__)
       )
     end
 
     def handle_request
       EM.synchrony do
         handler.handle_request(@parser.http_method, @url, @headers, @body).tap do |response|
-          if response.has_key?(:error)
+          if response.key?(:error)
             close_connection
-            raise "puffing-billy: #{response[:error]}"
+            fail "puffing-billy: #{response[:error]}"
           else
             send_response(response)
           end

data/lib/billy/proxy_request_stub.rb

@@ -3,10 +3,10 @@ require 'multi_json'
 module Billy
   class ProxyRequestStub
     def initialize(url, options = {})
-      @options = {:method => :get}.merge(options)
+      @options = { method: :get }.merge(options)
       @method = @options[:method].to_s.upcase
       @url = url
-      @response = {code: 204, headers: {}, text: ""}
+      @response = { code: 204, headers: {}, text: '' }
     end
 
     def and_return(response)
@@ -27,10 +27,10 @@ module Billy
       headers['Content-Type'] = res[:content_type] if res[:content_type]
 
       if res[:json]
-        headers = {'Content-Type' => 'application/json'}.merge(headers)
+        headers = { 'Content-Type' => 'application/json' }.merge(headers)
         body = MultiJson.dump(res[:json])
       elsif res[:jsonp]
-        headers = {'Content-Type' => 'application/javascript'}.merge(headers)
+        headers = { 'Content-Type' => 'application/javascript' }.merge(headers)
         if res[:callback]
           callback = res[:callback]
         elsif res[:callback_param]
@@ -40,11 +40,11 @@ module Billy
         end
         body = "#{callback}(#{MultiJson.dump(res[:jsonp])})"
       elsif res[:text]
-        headers = {'Content-Type' => 'text/plain'}.merge(headers)
+        headers = { 'Content-Type' => 'text/plain' }.merge(headers)
         body = res[:text]
       elsif res[:redirect_to]
         code = 302
-        headers = {'Location' => res[:redirect_to]}
+        headers = { 'Location' => res[:redirect_to] }
       else
         body = res[:body]
       end
@@ -57,7 +57,7 @@ module Billy
         if @url.is_a?(Regexp)
           url.match(@url)
         else
-          url.split('?')[0] == @url
+          Billy.config.strip_query_params ? (url.split('?')[0] == @url) : (url == @url)
         end
       end
     end

data/lib/billy/version.rb

@@ -1,3 +1,3 @@
 module Billy
-  VERSION = "0.4.1"
+  VERSION = '0.5.0'
 end

data/lib/tasks/billy.rake

@@ -1,7 +1,6 @@
 require 'addressable/uri'
 
 namespace :cache do
-
   desc 'Print out all cache file information'
   task :print_all do
     cache_array = load_cache
@@ -12,9 +11,9 @@ namespace :cache do
   end
 
   desc 'Print out specific cache file information'
-  task :print_details, :sha do |t, args|
-    raise "Missing sha; usage: rake cache:print_details['<sha>']" unless args[:sha]
-    cache_array = load_cache(Billy.config.cache_path, '*'+args[:sha]+'*.yml')
+  task :print_details, :sha do |_t, args|
+    fail "Missing sha; usage: rake cache:print_details['<sha>']" unless args[:sha]
+    cache_array = load_cache(Billy.config.cache_path, '*' + args[:sha] + '*.yml')
 
     sort_cache(cache_array).each do |cache|
       print_cache_details(cache)
@@ -22,10 +21,10 @@ namespace :cache do
   end
 
   desc 'Find specific cache files by URL'
-  task :find_by_url, :api_path do |t, args|
-    raise "Missing api path; usage: rake cache:find_by_url['<api_path>']" unless args[:api_path]
+  task :find_by_url, :api_path do |_t, args|
+    fail "Missing api path; usage: rake cache:find_by_url['<api_path>']" unless args[:api_path]
     cache_array = load_cache
-    filtered_cache_array = cache_array.select {|f| f[:url_path].include?(args[:api_path]) }
+    filtered_cache_array = cache_array.select { |f| f[:url_path].include?(args[:api_path]) }
 
     sort_cache(filtered_cache_array).each do |cache|
       print_cache_details(cache)
@@ -33,10 +32,10 @@ namespace :cache do
   end
 
   desc 'Find specific cache files by scope'
-  task :find_by_scope, :scope do |t, args|
-    raise "Missing scope; usage: rake cache:find_by_scope['<scope>']" unless args[:scope]
+  task :find_by_scope, :scope do |_t, args|
+    fail "Missing scope; usage: rake cache:find_by_scope['<scope>']" unless args[:scope]
     cache_array = load_cache
-    filtered_cache_array = cache_array.select {|f| f[:scope] && f[:scope].include?(args[:scope]) }
+    filtered_cache_array = cache_array.select { |f| f[:scope] && f[:scope].include?(args[:scope]) }
 
     sort_cache(filtered_cache_array).each do |cache|
       print_cache_details(cache)
@@ -46,7 +45,7 @@ namespace :cache do
   desc 'Find cache files with non-successful status codes'
   task :find_non_successful do
     cache_array = load_cache
-    filtered_cache_array = cache_array.select {|f| !(200..299).include?(f[:status]) }
+    filtered_cache_array = cache_array.select { |f| !(200..299).include?(f[:status]) }
 
     sort_cache(filtered_cache_array).each do |cache|
       print_cache_details(cache)
@@ -57,11 +56,11 @@ namespace :cache do
     cache_path  = Rails.root.join(cache_directory)
     cache_array = []
 
-    Dir.glob(cache_path+file_pattern) do |filename|
+    Dir.glob(cache_path + file_pattern) do |filename|
       data = load_cache_file(filename)
       url = Addressable::URI.parse(data[:url])
-      data[:url_path] = "#{url.path}#{url.query ? '?'+url.query : ''}#{url.fragment ? '#'+url.fragment : ''}"
-      data[:filename] = filename.gsub(Rails.root.to_s+'/','')
+      data[:url_path] = "#{url.path}#{url.query ? '?' + url.query : ''}#{url.fragment ? '#' + url.fragment : ''}"
+      data[:filename] = filename.gsub(Rails.root.to_s + '/', '')
       cache_array << data
     end
     cache_array
@@ -85,5 +84,4 @@ namespace :cache do
   def sort_cache(cache, key = :url_path)
     cache.sort_by { |hsh| hsh[key] }
   end
-
 end

data/puffing-billy.gemspec

@@ -2,36 +2,36 @@
 require File.expand_path('../lib/billy/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Olly Smith"]
-  gem.email         = ["olly.smith@gmail.com"]
-  gem.description   = %q{A stubbing proxy server for ruby. Connect it to your browser in integration tests to fake interactions with remote HTTP(S) servers.}
-  gem.summary       = %q{Easy request stubs for browser tests.}
-  gem.homepage      = "https://github.com/oesmith/puffing-billy"
+  gem.authors       = ['Olly Smith']
+  gem.email         = ['olly.smith@gmail.com']
+  gem.description   = 'A stubbing proxy server for ruby. Connect it to your browser in integration tests to fake interactions with remote HTTP(S) servers.'
+  gem.summary       = 'Easy request stubs for browser tests.'
+  gem.homepage      = 'https://github.com/oesmith/puffing-billy'
 
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "puffing-billy"
-  gem.require_paths = ["lib"]
+  gem.name          = 'puffing-billy'
+  gem.require_paths = ['lib']
   gem.version       = Billy::VERSION
 
-  gem.add_development_dependency "rspec"
-  gem.add_development_dependency "thin"
-  gem.add_development_dependency "faraday"
-  gem.add_development_dependency "poltergeist"
-  gem.add_development_dependency "selenium-webdriver"
-  gem.add_development_dependency "capybara"
-  gem.add_development_dependency "capybara-webkit", "~> 1.0"
-  gem.add_development_dependency "rack"
-  gem.add_development_dependency "guard"
-  gem.add_development_dependency "rb-inotify"
-  gem.add_development_dependency "pry"
-  gem.add_development_dependency "cucumber"
-  gem.add_runtime_dependency "addressable"
-  gem.add_runtime_dependency "eventmachine"
-  gem.add_runtime_dependency "em-synchrony"
-  gem.add_runtime_dependency "em-http-request"
-  gem.add_runtime_dependency "eventmachine_httpserver"
-  gem.add_runtime_dependency "http_parser.rb", "~> 0.6.0"
-  gem.add_runtime_dependency "multi_json"
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'thin'
+  gem.add_development_dependency 'faraday'
+  gem.add_development_dependency 'poltergeist'
+  gem.add_development_dependency 'selenium-webdriver'
+  gem.add_development_dependency 'capybara'
+  gem.add_development_dependency 'capybara-webkit', '~> 1.0'
+  gem.add_development_dependency 'rack'
+  gem.add_development_dependency 'guard'
+  gem.add_development_dependency 'rb-inotify'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'cucumber'
+  gem.add_runtime_dependency 'addressable'
+  gem.add_runtime_dependency 'eventmachine'
+  gem.add_runtime_dependency 'em-synchrony'
+  gem.add_runtime_dependency 'em-http-request', '~> 1.1.0'
+  gem.add_runtime_dependency 'eventmachine_httpserver'
+  gem.add_runtime_dependency 'http_parser.rb', '~> 0.6.0'
+  gem.add_runtime_dependency 'multi_json'
 end

data/spec/features/examples/facebook_api_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper'
 require 'base64'
 
-describe 'Facebook API example', :type => :feature, :js => true do
+describe 'Facebook API example', type: :feature, js: true do
   before do
-    proxy.stub('https://www.facebook.com:443/dialog/oauth').and_return(Proc.new { |params,_,_|
+    proxy.stub('https://www.facebook.com:443/dialog/oauth').and_return(proc do |params, _, _|
       # mock a signed request from facebook.  the JS api never verifies the
       # signature, so all it needs is the base64-encoded payload
       signed_request = "xxxxxxxxxx.#{Base64.encode64('{"user_id":"1234567"}')}"
       # redirect to the 'redirect_uri', with some extra crap in the query string
-      {:redirect_to => "#{params['redirect_uri'][0]}&access_token=foobar&expires_in=600&base_domain=localhost&https=1&signed_request=#{signed_request}"}
-    })
+      { redirect_to: "#{params['redirect_uri'][0]}&access_token=foobar&expires_in=600&base_domain=localhost&https=1&signed_request=#{signed_request}" }
+    end)
 
-    proxy.stub('https://graph.facebook.com:443/me').and_return(:jsonp => {:name => 'Tester 1'})
+    proxy.stub('https://graph.facebook.com:443/me').and_return(jsonp: { name: 'Tester 1' })
   end
 
   it 'should show me as logged-in' do
     visit '/facebook_api.html'
-    click_on "Login"
-    expect(page).to have_content "Hi, Tester 1"
+    click_on 'Login'
+    expect(page).to have_content 'Hi, Tester 1'
   end
 end

data/spec/features/examples/tumblr_api_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe 'Tumblr API example', :type => :feature, :js => true do
+describe 'Tumblr API example', type: :feature, js: true do
   before do
     proxy.stub('http://blog.howmanyleft.co.uk/api/read/json').and_return(
-      :jsonp => {
-        :posts => [
+      jsonp: {
+        posts: [
           {
             'regular-title' => 'News Item 1',
             'url-with-slug' => 'http://example.com/news/1',
@@ -16,14 +16,14 @@ describe 'Tumblr API example', :type => :feature, :js => true do
             'regular-body' => 'News item 2 content here'
           }
         ]
-    })
+      })
   end
 
   it 'should show news stories' do
     visit '/tumblr_api.html'
-    expect(page).to have_link('News Item 1', :href => 'http://example.com/news/1')
+    expect(page).to have_link('News Item 1', href: 'http://example.com/news/1')
     expect(page).to have_content('News item 1 content here')
-    expect(page).to have_link('News Item 2', :href => 'http://example.com/news/2')
+    expect(page).to have_link('News Item 2', href: 'http://example.com/news/2')
     expect(page).to have_content('News item 2 content here')
   end
 end

data/spec/lib/billy/cache_spec.rb

@@ -27,13 +27,13 @@ describe Billy::Cache do
         expect { cache.format_url(pipe_url) }.not_to raise_error
       end
 
-      context "when dynamic_jsonp is true" do
+      context 'when dynamic_jsonp is true' do
         it 'omits the callback param by default' do
           expect(cache.format_url(params_url_with_callback, false, true)).to eq params_url
         end
 
         it 'omits the params listed in Billy.config.dynamic_jsonp_keys' do
-          allow(Billy.config).to receive(:dynamic_jsonp_keys) { ["foo"] }
+          allow(Billy.config).to receive(:dynamic_jsonp_keys) { ['foo'] }
 
           expect(cache.format_url(params_url_with_callback, false, true)).to eq "#{base_url}?callback=quux"
         end
@@ -56,11 +56,10 @@ describe Billy::Cache do
       end
     end
 
-    context "with merge_cached_responses_whitelist set" do
-
-      let(:analytics_url1) { "http://www.example-analytics.com/user/SDF879932/" }
-      let(:analytics_url2) { "http://www.example-analytics.com/user/OIWEMLW39/" }
-      let(:regular_url) { "http://www.example-analytics.com/user.js" }
+    context 'with merge_cached_responses_whitelist set' do
+      let(:analytics_url1) { 'http://www.example-analytics.com/user/SDF879932/' }
+      let(:analytics_url2) { 'http://www.example-analytics.com/user/OIWEMLW39/' }
+      let(:regular_url) { 'http://www.example-analytics.com/user.js' }
 
       let(:regex_to_match_analytics_urls_only) do
         # Note that it matches the forward slash at the end of the URL, which doesn't match regular_url:
@@ -74,19 +73,18 @@ describe Billy::Cache do
       end
 
       it "has one cache key for the two analytics urls that match, and a separate one for the other that doesn't" do
-        expect(cache.key("post", analytics_url1, "body")).to eq cache.key("post", analytics_url2, "body")
-        expect(cache.key("post", analytics_url1, "body")).not_to eq cache.key("post", regular_url, "body")
+        expect(cache.key('post', analytics_url1, 'body')).to eq cache.key('post', analytics_url2, 'body')
+        expect(cache.key('post', analytics_url1, 'body')).not_to eq cache.key('post', regular_url, 'body')
       end
 
-      it "More specifically, the cache keys should be identical for the 2 analytics urls" do
-        identical_cache_key = "post_5fcb7a450e4cd54dcffcb526212757ee0ca9dc17"
-        distinct_cache_key = "post_www.example-analytics.com_81f097654a523bd7ddb10fd4aee781723e076a1a_02083f4579e08a612425c0c1a17ee47add783b94"
+      it 'More specifically, the cache keys should be identical for the 2 analytics urls' do
+        identical_cache_key = 'post_5fcb7a450e4cd54dcffcb526212757ee0ca9dc17'
+        distinct_cache_key = 'post_www.example-analytics.com_81f097654a523bd7ddb10fd4aee781723e076a1a_02083f4579e08a612425c0c1a17ee47add783b94'
 
-        expect(cache.key("post", analytics_url1, "body")).to eq identical_cache_key
-        expect(cache.key("post", regular_url, "body")).to eq distinct_cache_key
-        expect(cache.key("post", analytics_url2, "body")).to eq identical_cache_key
+        expect(cache.key('post', analytics_url1, 'body')).to eq identical_cache_key
+        expect(cache.key('post', regular_url, 'body')).to eq distinct_cache_key
+        expect(cache.key('post', analytics_url2, 'body')).to eq identical_cache_key
       end
-
     end
   end
 end

data/spec/lib/billy/handlers/cache_handler_spec.rb

@@ -2,13 +2,15 @@ require 'spec_helper'
 
 describe Billy::CacheHandler do
   let(:handler) { Billy::CacheHandler.new }
-  let(:request) { {
+  let(:request) do
+    {
       method:   'post',
       url:      'http://example.test:8080/index?some=param&callback=dynamicCallback5678',
-      headers:  {'Accept-Encoding'  => 'gzip',
-                 'Cache-Control'    => 'no-cache' },
+      headers:  { 'Accept-Encoding'  => 'gzip',
+                  'Cache-Control'    => 'no-cache' },
       body:     'Some body'
-  } }
+    }
+  end
 
   it 'delegates #reset to the cache' do
     expect(Billy::Cache.instance).to receive(:reset).at_least(:once)
@@ -23,12 +25,12 @@ describe Billy::CacheHandler do
   describe '#handles_request?' do
     it 'handles the request if it is cached' do
       expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-      expect(handler.handles_request?(nil,nil,nil,nil)).to be true
+      expect(handler.handles_request?(nil, nil, nil, nil)).to be true
     end
 
     it 'does not handle the request if it is not cached' do
       expect(Billy::Cache.instance).to receive(:cached?).and_return(false)
-      expect(handler.handles_request?(nil,nil,nil,nil)).to be false
+      expect(handler.handles_request?(nil, nil, nil, nil)).to be false
     end
   end
 
@@ -43,11 +45,11 @@ describe Billy::CacheHandler do
 
     it 'returns a cached response if the request can be handled' do
       expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-      expect(Billy::Cache.instance).to receive(:fetch).and_return({:status=>200, :headers=>{"Connection"=>"close"}, :content=>"The response body"})
+      expect(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: 'The response body')
       expect(handler.handle_request(request[:method],
                                     request[:url],
                                     request[:headers],
-                                    request[:body])).to eql({:status=>200, :headers=>{"Connection"=>"close"}, :content=>"The response body"})
+                                    request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'The response body')
     end
 
     context 'updating jsonp callback names enabled' do
@@ -57,20 +59,20 @@ describe Billy::CacheHandler do
 
       it 'updates the cached response if the callback is dynamic' do
         expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-        expect(Billy::Cache.instance).to receive(:fetch).and_return({:status=>200, :headers=>{"Connection"=>"close"}, :content=> 'dynamicCallback1234({"yolo":"kitten"})'})
+        expect(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback1234({"yolo":"kitten"})')
         expect(handler.handle_request(request[:method],
                                       request[:url],
                                       request[:headers],
-                                      request[:body])).to eql({:status=>200, :headers=>{"Connection"=>"close"}, :content=>'dynamicCallback5678({"yolo":"kitten"})'})
+                                      request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback5678({"yolo":"kitten"})')
       end
 
       it 'is flexible about the format of the response body' do
         expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-        expect(Billy::Cache.instance).to receive(:fetch).and_return({:status=>200, :headers=>{"Connection"=>"close"}, :content=> "/**/ dynamicCallback1234(\n{\"yolo\":\"kitten\"})"})
+        expect(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: "/**/ dynamicCallback1234(\n{\"yolo\":\"kitten\"})")
         expect(handler.handle_request(request[:method],
                                       request[:url],
                                       request[:headers],
-                                      request[:body])).to eql({:status=>200, :headers=>{"Connection"=>"close"}, :content=>"/**/ dynamicCallback5678(\n{\"yolo\":\"kitten\"})"})
+                                      request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: "/**/ dynamicCallback5678(\n{\"yolo\":\"kitten\"})")
       end
 
       it 'does not interfere with non-jsonp requests' do
@@ -78,22 +80,22 @@ describe Billy::CacheHandler do
         other_request = {
           method:  'get',
           url:     'http://example.test:8080/index?hanukkah=latkes',
-          headers: {'Accept-Encoding'=>'gzip', 'Cache-Control'=>'no-cache' },
+          headers: { 'Accept-Encoding' => 'gzip', 'Cache-Control' => 'no-cache' },
           body:    'no jsonp'
         }
 
         allow(Billy::Cache.instance).to receive(:cached?).and_return(true)
-        allow(Billy::Cache.instance).to receive(:fetch).with(jsonp_request[:method], jsonp_request[:url], jsonp_request[:body]).and_return({:status=>200,
-                      :headers=>{"Connection"=>"close"},
-                      :content=> 'dynamicCallback1234({"yolo":"kitten"})'})
-        allow(Billy::Cache.instance).to receive(:fetch).with(other_request[:method], other_request[:url], other_request[:body]).and_return({:status=>200,
-                      :headers=>{"Connection"=>"close"},
-                      :content=> 'no jsonp but has parentheses()'})
+        allow(Billy::Cache.instance).to receive(:fetch).with(jsonp_request[:method], jsonp_request[:url], jsonp_request[:body]).and_return(status: 200,
+                                                                                                                                           headers: { 'Connection' => 'close' },
+                                                                                                                                           content: 'dynamicCallback1234({"yolo":"kitten"})')
+        allow(Billy::Cache.instance).to receive(:fetch).with(other_request[:method], other_request[:url], other_request[:body]).and_return(status: 200,
+                                                                                                                                           headers: { 'Connection' => 'close' },
+                                                                                                                                           content: 'no jsonp but has parentheses()')
 
         expect(handler.handle_request(other_request[:method],
-          other_request[:url],
-          other_request[:headers],
-          other_request[:body])).to eql({:status=>200, :headers=>{"Connection"=>"close"}, :content=>'no jsonp but has parentheses()'})
+                                      other_request[:url],
+                                      other_request[:headers],
+                                      other_request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'no jsonp but has parentheses()')
       end
     end
 
@@ -104,11 +106,11 @@ describe Billy::CacheHandler do
 
       it 'does not change the response' do
         expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-        expect(Billy::Cache.instance).to receive(:fetch).and_return({:status=>200, :headers=>{"Connection"=>"close"}, :content=> 'dynamicCallback1234({"yolo":"kitten"})'})
+        expect(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback1234({"yolo":"kitten"})')
         expect(handler.handle_request(request[:method],
                                       request[:url],
                                       request[:headers],
-                                      request[:body])).to eql({:status=>200, :headers=>{"Connection"=>"close"}, :content=>'dynamicCallback1234({"yolo":"kitten"})'})
+                                      request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback1234({"yolo":"kitten"})')
       end
     end