puffing-billy 2.3.1 → 3.0.1

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

@@ -1,191 +0,0 @@
-require 'spec_helper'
-
-describe Billy::CacheHandler do
-  let(:handler) { Billy::CacheHandler.new }
-  let(:request_url) { 'http://example.test:8080/index?some=param&callback=dynamicCallback5678' }
-  let(:request) do
-    {
-      method:   'post',
-      url:      request_url,
-      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)
-    handler.reset
-  end
-
-  it 'delegates #cached? to the cache' do
-    expect(Billy::Cache.instance).to receive :cached?
-    handler.cached?
-  end
-
-  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
-    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
-    end
-  end
-
-  describe '#handle_request' do
-    it 'returns nil if the request cannot be handled' do
-      expect(Billy::Cache.instance).to receive(:cached?).and_return(false)
-      expect(handler.handle_request(request[:method],
-                                    request[:url],
-                                    request[:headers],
-                                    request[:body])).to be nil
-    end
-
-    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(handler.handle_request(request[:method],
-                                    request[:url],
-                                    request[:headers],
-                                    request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'The response body')
-    end
-
-    context 'updating jsonp callback names enabled' do
-      before do
-        Billy.config.dynamic_jsonp = true
-      end
-
-      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(handler.handle_request(request[:method],
-                                      request[:url],
-                                      request[:headers],
-                                      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(handler.handle_request(request[:method],
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: "/**/ dynamicCallback5678(\n{\"yolo\":\"kitten\"})")
-      end
-
-      it 'does not interfere with non-jsonp requests' do
-        jsonp_request = request
-        other_request = {
-          method:  'get',
-          url:     'http://example.test:8080/index?hanukkah=latkes',
-          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()')
-
-        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()')
-      end
-
-      context 'when after_cache_handles_request is set' do
-        it "should call the callback with the request and response" do
-          allow(Billy.config).to receive(:after_cache_handles_request) do
-            proc do |request, response|
-              response[:headers]['Access-Control-Allow-Origin'] = "*"
-              response[:content] = request[:body]
-            end
-          end
-          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(handler.handle_request(request[:method],
-                                        request[:url],
-                                        request[:headers],
-                                        request[:body])).to eql(status: 200, headers: { 'Connection' => 'close', 'Access-Control-Allow-Origin' => "*" }, content: 'Some body')
-        end
-      end
-
-      context 'when dynamic_jsonp_callback_name is set' do
-        let(:dynamic_jsonp_callback_name) { 'customCallback' }
-        let(:request_url) { "http://example.test:8080/index?some=param&#{dynamic_jsonp_callback_name}=dynamicCallback5678" }
-
-        before do
-          allow(Billy.config).to receive(:dynamic_jsonp_callback_name) do
-            dynamic_jsonp_callback_name
-          end
-        end
-
-        it 'should call the callback with the specified name' 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(handler.handle_request(request[:method],
-                                        request[:url],
-                                        request[:headers],
-                                        request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback5678({"yolo":"kitten"})')
-        end
-      end
-    end
-
-    context 'updating jsonp callback names disabled' do
-      before do
-        Billy.config.dynamic_jsonp = false
-      end
-
-      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(handler.handle_request(request[:method],
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback1234({"yolo":"kitten"})')
-      end
-    end
-
-    it 'returns nil if the Cache fails to handle the response for some reason' do
-      expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-      expect(Billy::Cache.instance).to receive(:fetch).and_return(nil)
-      expect(handler.handle_request(request[:method],
-                                    request[:url],
-                                    request[:headers],
-                                    request[:body])).to be nil
-    end
-
-    context 'network delay simulation' do
-      before do
-        allow(Billy::Cache.instance).to receive(:cached?).and_return(true)
-        allow(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback1234({"yolo":"kitten"})')
-      end
-
-      context 'when cache_simulates_network_delays is disabled' do
-        it 'does not sleep for default delay before responding' do
-          expect(Kernel).not_to receive(:sleep)
-          handler.handle_request(request[:method], request[:url], request[:headers], request[:body])
-        end
-      end
-
-      context 'when cache_simulates_network_delays is enabled' do
-        around do |example|
-          Billy.config.cache_simulates_network_delays = true
-          example.call
-          Billy.config.cache_simulates_network_delays = false
-        end
-
-        it 'sleeps for default delay before responding' do
-          expect(Kernel).to receive(:sleep).with(Billy.config.cache_simulates_network_delay_time)
-          handler.handle_request(request[:method], request[:url], request[:headers], request[:body])
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Billy::Handler do
-  let(:handler) { Class.new { include Billy::Handler }.new }
-  it '#handle_request raises an error if not overridden' do
-    expect(handler.handle_request(nil, nil, nil, nil)).to eql(error: 'The handler has not overridden the handle_request method!')
-  end
-
-  it '#handles_request returns false by default' do
-    expect(handler.handles_request?(nil, nil, nil, nil)).to be false
-  end
-
-  it 'responds to #reset' do
-    expect(handler).to respond_to :reset
-  end
-end

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

@@ -1,254 +0,0 @@
-require 'spec_helper'
-
-describe Billy::ProxyHandler do
-  subject { Billy::ProxyHandler.new }
-  let(:request) do
-    {
-      method:   'post',
-      url:      'http://usern:pw@example.test:8080/index?some=param',
-      headers:  { 'Accept-Encoding'  => 'gzip',
-                  'Cache-Control'    => 'no-cache' },
-      body:     'Some body'
-    }
-  end
-
-  describe '#handles_request?' do
-    context 'with non-whitelisted requests enabled' do
-      before do
-        expect(Billy.config).to receive(:non_whitelisted_requests_disabled).and_return(false)
-      end
-
-      it 'handles all requests' do
-        expect(subject.handles_request?(request[:method],
-                                        request[:url],
-                                        request[:headers],
-                                        request[:body])).to be true
-      end
-    end
-    context 'with non-whitelisted requests disabled' do
-      before do
-        expect(Billy.config).to receive(:non_whitelisted_requests_disabled).and_return(true)
-      end
-
-      it 'does not handle requests that are not white or black listed' do
-        expect(subject.handles_request?(request[:method],
-                                        request[:url],
-                                        request[:headers],
-                                        request[:body])).to be false
-      end
-
-      context 'a whitelisted host' do
-        context 'with a blacklisted path' do
-          before do
-            expect(Billy.config).to receive(:path_blacklist) { ['/index'] }
-          end
-
-          it 'does not handle requests for blacklisted paths' do
-            expect(subject.handles_request?(request[:method],
-                                            'http://example.test:8080/index?some=param',
-                                            request[:headers],
-                                            request[:body])).to be false
-          end
-        end
-
-        context 'as a regex' do
-          before do
-            expect(Billy.config).to receive(:whitelist) { [%r{example\.test\/a}] }
-          end
-
-          it 'handles requests for the host without a port' do
-            expect(subject.handles_request?(request[:method],
-                                            'http://example.test/a',
-                                            request[:headers],
-                                            request[:body])).to be true
-          end
-
-          it 'handles requests for the host with a port' do
-            expect(subject.handles_request?(request[:method],
-                                            'http://example.test:8080/a',
-                                            request[:headers],
-                                            request[:body])).to be true
-          end
-        end
-
-        context 'without a port' do
-          before do
-            expect(Billy.config).to receive(:whitelist) { ['example.test'] }
-          end
-
-          it 'handles requests for the host without a port' do
-            expect(subject.handles_request?(request[:method],
-                                            'http://example.test',
-                                            request[:headers],
-                                            request[:body])).to be true
-          end
-
-          it 'handles requests for the host with a port' do
-            expect(subject.handles_request?(request[:method],
-                                            'http://example.test:8080',
-                                            request[:headers],
-                                            request[:body])).to be true
-          end
-        end
-
-        context 'with a port' do
-          before do
-            expect(Billy.config).to receive(:whitelist) { ['example.test:8080'] }
-          end
-
-          it 'does not handle requests whitelisted for a specific port' do
-            expect(subject.handles_request?(request[:method],
-                                            'http://example.test',
-                                            request[:headers],
-                                            request[:body])).to be false
-          end
-
-          it 'handles requests for the host with a port' do
-            expect(subject.handles_request?(request[:method],
-                                            'http://example.test:8080',
-                                            request[:headers],
-                                            request[:body])).to be true
-          end
-        end
-      end
-    end
-  end
-
-  describe '#handle_request' do
-    it 'returns nil if it does not handle the request' do
-      expect(subject).to receive(:handles_request?).and_return(false)
-      expect(subject.handle_request(request[:method],
-                                    request[:url],
-                                    request[:headers],
-                                    request[:body])).to be nil
-    end
-
-    context 'with a handled request' do
-      let(:response_header) do
-        header = Struct.new(:status, :raw).new
-        header.status = 200
-        header.raw = {}
-        header
-      end
-
-      let(:em_response)     { double('response') }
-      let(:em_request)      do
-        double('EM::HttpRequest', error: nil, response: em_response, response_header: response_header)
-      end
-
-      before do
-        allow(subject).to receive(:handles_request?).and_return(true)
-        allow(em_response).to receive(:force_encoding).and_return('The response body')
-        allow(EventMachine::HttpRequest).to receive(:new).and_return(em_request)
-        expect(em_request).to receive(:post).and_return(em_request)
-      end
-
-      it 'returns any error in the response' do
-        allow(em_request).to receive(:error).and_return('ERROR!')
-        expect(subject.handle_request(request[:method],
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to eql(error: "Request to #{request[:url]} failed with error: ERROR!")
-      end
-
-      it 'returns a hashed response if the request succeeds' do
-        expect(subject.handle_request(request[:method],
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'The response body')
-      end
-
-      it 'returns nil if both the error and response are for some reason nil' do
-        allow(em_request).to receive(:response).and_return(nil)
-        expect(subject.handle_request(request[:method],
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to be nil
-      end
-
-      it 'caches the response if cacheable' do
-        expect(subject).to receive(:allowed_response_code?).and_return(true)
-        expect(Billy::Cache.instance).to receive(:store)
-        subject.handle_request(request[:method],
-                               request[:url],
-                               request[:headers],
-                               request[:body])
-      end
-
-      it 'does NOT cache the response if the host is whitelisted but not cache_whitelisted' do
-        uri = Addressable::URI.parse(request[:url])
-
-        expect(subject).to receive(:allowed_response_code?).and_return(true)
-        expect(Billy.config).to receive(:whitelist).and_return([uri.host])
-        expect(Billy.config).to receive(:cache_whitelist).and_return([])
-
-        expect(Billy::Cache.instance).not_to receive(:store)
-        subject.handle_request(request[:method],
-                               request[:url],
-                               request[:headers],
-                               request[:body])
-      end
-
-      it 'caches the response if the host is whitelisted AND cache_whitelisted' do
-        uri = Addressable::URI.parse(request[:url])
-
-        expect(subject).to receive(:allowed_response_code?).and_return(true)
-        expect(Billy.config).to receive(:whitelist).and_return([uri.host])
-        expect(Billy.config).to receive(:cache_whitelist).and_return([uri.host])
-
-        expect(Billy::Cache.instance).to receive(:store)
-        subject.handle_request(request[:method],
-                               request[:url],
-                               request[:headers],
-                               request[:body])
-      end
-
-      it 'uses the timeouts defined in configuration' do
-        allow(Billy.config).to receive(:proxied_request_inactivity_timeout).and_return(42)
-        allow(Billy.config).to receive(:proxied_request_connect_timeout).and_return(24)
-
-        expect(EventMachine::HttpRequest).to receive(:new).with(request[:url],
-                                                                inactivity_timeout: 42,
-                                                                connect_timeout: 24
-        )
-
-        subject.handle_request(request[:method],
-                               request[:url],
-                               request[:headers],
-                               request[:body])
-      end
-
-      it 'uses the internal proxy settings defined in configuration' do
-        allow(Billy.config).to receive(:proxied_request_host).and_return('10.10.10.10')
-        allow(Billy.config).to receive(:proxied_request_port).and_return('2080')
-
-        expect(EventMachine::HttpRequest).to receive(:new).with(request[:url],
-                                                                inactivity_timeout: 10,
-                                                                connect_timeout: 5,
-                                                                proxy: { host: '10.10.10.10', port: '2080' }
-        )
-
-        subject.handle_request(request[:method],
-                               request[:url],
-                               request[:headers],
-                               request[:body])
-      end
-    end
-  end
-
-  describe '#build_request_options' do
-    it 'creates authorization header when URL has basic auth' do
-      request_options = subject.send(:build_request_options, request[:url],
-                                                             request[:headers],
-                                                             request[:body])
-      expect(request_options[:head]).to have_key 'authorization'
-    end
-
-    it 'does not include authorization header without basic auth' do
-      request_options = subject.send(:build_request_options, request[:url].gsub('usern:pw@',''),
-                                                             request[:headers],
-                                                             request[:body])
-      expect(request_options[:head]).not_to have_key 'authorization'
-    end
-  end
-end

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

@@ -1,200 +0,0 @@
-require 'spec_helper'
-
-describe Billy::RequestHandler do
-  subject { Billy::RequestHandler.new }
-
-  it 'implements Handler' do
-    expect(subject).to be_a Billy::Handler
-  end
-
-  describe '#handlers' do
-    it 'has a stub handler' do
-      expect(subject.handlers[:stubs]).to be_a Billy::StubHandler
-    end
-
-    it 'has a cache handler' do
-      expect(subject.handlers[:cache]).to be_a Billy::CacheHandler
-    end
-
-    it 'has a proxy handler' do
-      expect(subject.handlers[:proxy]).to be_a Billy::ProxyHandler
-    end
-  end
-
-  context 'with stubbed handlers' do
-    let(:args) { %w(get url headers body) }
-    let(:stub_handler) { double('StubHandler') }
-    let(:cache_handler) { double('CacheHandler') }
-    let(:proxy_handler) { double('ProxyHandler') }
-    let(:handlers) do
-      {
-        stubs: stub_handler,
-        cache: cache_handler,
-        proxy: proxy_handler
-      }
-    end
-
-    before do
-      allow(subject).to receive(:handlers).and_return(handlers)
-    end
-
-    describe '#handles_request?' do
-      it 'returns false if no handlers handle the request' do
-        handlers.each do |_key, handler|
-          expect(handler).to receive(:handles_request?).with(*args).and_return(false)
-        end
-        expect(subject.handles_request?(*args)).to be false
-      end
-
-      it 'returns true immediately if the stub handler handles the request' do
-        expect(stub_handler).to receive(:handles_request?).with(*args).and_return(true)
-        expect(cache_handler).to_not receive(:handles_request?)
-        expect(proxy_handler).to_not receive(:handles_request?)
-        expect(subject.handles_request?(*args)).to be true
-      end
-
-      it 'returns true if the cache handler handles the request' do
-        expect(stub_handler).to receive(:handles_request?).with(*args).and_return(false)
-        expect(cache_handler).to receive(:handles_request?).with(*args).and_return(true)
-        expect(proxy_handler).to_not receive(:handles_request?)
-        expect(subject.handles_request?(*args)).to be true
-      end
-
-      it 'returns true if the proxy handler handles the request' do
-        expect(stub_handler).to receive(:handles_request?).with(*args).and_return(false)
-        expect(cache_handler).to receive(:handles_request?).with(*args).and_return(false)
-        expect(proxy_handler).to receive(:handles_request?).with(*args).and_return(true)
-        expect(subject.handles_request?(*args)).to be true
-      end
-    end
-
-    describe '#handle_request' do
-      before do
-        allow(Billy::config).to receive(:record_requests).and_return(true)
-      end
-
-      it 'returns stubbed responses' do
-        expect(stub_handler).to receive(:handle_request).with(*args).and_return('foo')
-        expect(cache_handler).to_not receive(:handle_request)
-        expect(proxy_handler).to_not receive(:handle_request)
-        expect(subject.handle_request(*args)).to eql 'foo'
-        expect(subject.requests).to eql([{status: :complete, handler: :stubs, method: 'get', url: 'url', headers: 'headers', body: 'body'}])
-      end
-
-      it 'returns cached responses' do
-        expect(stub_handler).to receive(:handle_request).with(*args)
-        expect(cache_handler).to receive(:handle_request).with(*args).and_return('bar')
-        expect(proxy_handler).to_not receive(:handle_request)
-        expect(subject.handle_request(*args)).to eql 'bar'
-        expect(subject.requests).to eql([{status: :complete, handler: :cache, method: 'get', url: 'url', headers: 'headers', body: 'body'}])
-      end
-
-      it 'returns proxied responses' do
-        expect(stub_handler).to receive(:handle_request).with(*args)
-        expect(cache_handler).to receive(:handle_request).with(*args)
-        expect(proxy_handler).to receive(:handle_request).with(*args).and_return('baz')
-        expect(subject.handle_request(*args)).to eql 'baz'
-        expect(subject.requests).to eql([{status: :complete, handler: :proxy, method: 'get', url: 'url', headers: 'headers', body: 'body'}])
-      end
-
-      it 'returns an error hash if request is not handled' do
-        expect(stub_handler).to receive(:handle_request).with(*args)
-        expect(cache_handler).to receive(:handle_request).with(*args)
-        expect(proxy_handler).to receive(:handle_request).with(*args)
-        expect(subject.handle_request(*args)).to eql(error: 'Connection to url not cached and new http connections are disabled')
-        expect(subject.requests).to eql([{status: :complete, handler: :error, method: 'get', url: 'url', headers: 'headers', body: 'body'}])
-      end
-
-      it 'returns an error hash with body message if request cached based on body is not handled' do
-        args[0] = Billy.config.cache_request_body_methods[0]
-        expect(stub_handler).to receive(:handle_request).with(*args)
-        expect(cache_handler).to receive(:handle_request).with(*args)
-        expect(proxy_handler).to receive(:handle_request).with(*args)
-        expect(subject.handle_request(*args)).to eql(error: "Connection to url with body 'body' not cached and new http connections are disabled")
-        expect(subject.requests).to eql([{status: :complete, handler: :error, method: 'post', url: 'url', headers: 'headers', body: 'body'}])
-      end
-
-      it 'returns an error hash on unhandled exceptions' do
-        # Allow handling requests initially
-        allow(stub_handler).to receive(:handle_request)
-        allow(cache_handler).to receive(:handle_request)
-
-        allow(proxy_handler).to receive(:handle_request).and_raise("Any Proxy Error")
-        expect(subject.handle_request(*args)).to eql(error: "Any Proxy Error")
-
-        allow(cache_handler).to receive(:handle_request).and_raise("Any Cache Error")
-        expect(subject.handle_request(*args)).to eql(error: "Any Cache Error")
-
-        allow(stub_handler).to receive(:handle_request).and_raise("Any Stub Error")
-        expect(subject.handle_request(*args)).to eql(error: "Any Stub Error")
-      end
-
-      context 'before_handle_request activated' do
-        before do
-          handle_request = proc { |method, url, headers, body|
-            [method, url, headers, "#{body}_modified"]
-          }
-          allow(Billy::config).to receive(:before_handle_request).and_return(handle_request)
-        end
-
-        after do
-          allow(Billy::config).to receive(:before_handle_request).and_call_original
-        end
-
-        it 'modify request before handling' do
-          new_args = %w(get url headers body_modified)
-          expect(stub_handler).to receive(:handle_request).with(*new_args)
-          expect(cache_handler).to receive(:handle_request).with(*new_args).and_return('bar')
-          expect(proxy_handler).to_not receive(:handle_request)
-          expect(subject.handle_request(*args)).to eql 'bar'
-          expect(subject.requests).to eql([{status: :complete, handler: :cache, method: 'get', url: 'url', headers: 'headers', body: 'body'}])
-        end
-      end
-    end
-
-    describe '#stubs' do
-      it 'delegates to the stub_handler' do
-        expect(stub_handler).to receive(:stubs)
-        subject.stubs
-      end
-    end
-
-    describe '#stub' do
-      it 'delegates to the stub_handler' do
-        expect(stub_handler).to receive(:stub).with('some args')
-        subject.stub('some args')
-      end
-    end
-
-    describe '#reset' do
-      it 'resets all of the handlers' do
-        handlers.each do |_key, handler|
-          expect(handler).to receive(:reset)
-        end
-        expect(subject.request_log).to receive(:reset)
-        subject.reset
-      end
-    end
-
-    describe '#reset_stubs' do
-      it 'resets the stub handler' do
-        expect(stub_handler).to receive(:reset)
-        subject.reset_stubs
-      end
-    end
-
-    describe '#reset_cache' do
-      it 'resets the cache handler' do
-        expect(cache_handler).to receive(:reset)
-        subject.reset_cache
-      end
-    end
-
-    describe '#restore_cache' do
-      it 'resets the cache handler' do
-        expect(cache_handler).to receive(:reset)
-        subject.reset_cache
-      end
-    end
-  end
-end