faraday 1.0.1 → 1.10.3

data/spec/faraday/adapter/test_spec.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Adapter::Test do
+  let(:stubs) do
+    described_class::Stubs.new do |stub|
+      stub.get('http://domain.test/hello') do
+        [200, { 'Content-Type' => 'text/html' }, 'domain: hello']
+      end
+
+      stub.get('http://wrong.test/hello') do
+        [200, { 'Content-Type' => 'text/html' }, 'wrong: hello']
+      end
+
+      stub.get('http://wrong.test/bait') do
+        [404, { 'Content-Type' => 'text/html' }]
+      end
+
+      stub.get('/hello') do
+        [200, { 'Content-Type' => 'text/html' }, 'hello']
+      end
+
+      stub.get('/method-echo') do |env|
+        [200, { 'Content-Type' => 'text/html' }, env[:method].to_s]
+      end
+
+      stub.get(%r{\A/resources/\d+(?:\?|\z)}) do
+        [200, { 'Content-Type' => 'text/html' }, 'show']
+      end
+
+      stub.get(%r{\A/resources/(specified)\z}) do |_env, meta|
+        [200, { 'Content-Type' => 'text/html' }, "show #{meta[:match_data][1]}"]
+      end
+    end
+  end
+
+  let(:connection) do
+    Faraday.new do |builder|
+      builder.adapter :test, stubs
+    end
+  end
+
+  let(:response) { connection.get('/hello') }
+
+  context 'with simple path sets status' do
+    subject { response.status }
+
+    it { is_expected.to eq 200 }
+  end
+
+  context 'with simple path sets headers' do
+    subject { response.headers['Content-Type'] }
+
+    it { is_expected.to eq 'text/html' }
+  end
+
+  context 'with simple path sets body' do
+    subject { response.body }
+
+    it { is_expected.to eq 'hello' }
+  end
+
+  context 'with host points to the right stub' do
+    subject { connection.get('http://domain.test/hello').body }
+
+    it { is_expected.to eq 'domain: hello' }
+  end
+
+  describe 'can be called several times' do
+    subject { connection.get('/hello').body }
+
+    it { is_expected.to eq 'hello' }
+  end
+
+  describe 'can handle regular expression path' do
+    subject { connection.get('/resources/1').body }
+
+    it { is_expected.to eq 'show' }
+  end
+
+  describe 'can handle single parameter block' do
+    subject { connection.get('/method-echo').body }
+
+    it { is_expected.to eq 'get' }
+  end
+
+  describe 'can handle regular expression path with captured result' do
+    subject { connection.get('/resources/specified').body }
+
+    it { is_expected.to eq 'show specified' }
+  end
+
+  context 'with get params' do
+    subject { connection.get('/param?a=1').body }
+
+    before do
+      stubs.get('/param?a=1') { [200, {}, 'a'] }
+    end
+
+    it { is_expected.to eq 'a' }
+  end
+
+  describe 'ignoring unspecified get params' do
+    before do
+      stubs.get('/optional?a=1') { [200, {}, 'a'] }
+    end
+
+    context 'with multiple params' do
+      subject { connection.get('/optional?a=1&b=1').body }
+
+      it { is_expected.to eq 'a' }
+    end
+
+    context 'with single param' do
+      subject { connection.get('/optional?a=1').body }
+
+      it { is_expected.to eq 'a' }
+    end
+
+    context 'without params' do
+      subject(:request) { connection.get('/optional') }
+
+      it do
+        expect { request }.to raise_error(
+          Faraday::Adapter::Test::Stubs::NotFound
+        )
+      end
+    end
+  end
+
+  context 'with http headers' do
+    before do
+      stubs.get('/yo', 'X-HELLO' => 'hello') { [200, {}, 'a'] }
+      stubs.get('/yo') { [200, {}, 'b'] }
+    end
+
+    context 'with header' do
+      subject do
+        connection.get('/yo') { |env| env.headers['X-HELLO'] = 'hello' }.body
+      end
+
+      it { is_expected.to eq 'a' }
+    end
+
+    context 'without header' do
+      subject do
+        connection.get('/yo').body
+      end
+
+      it { is_expected.to eq 'b' }
+    end
+  end
+
+  describe 'different outcomes for the same request' do
+    def make_request
+      connection.get('/foo')
+    end
+
+    subject(:request) { make_request.body }
+
+    before do
+      stubs.get('/foo') { [200, { 'Content-Type' => 'text/html' }, 'hello'] }
+      stubs.get('/foo') { [200, { 'Content-Type' => 'text/html' }, 'world'] }
+    end
+
+    context 'the first request' do
+      it { is_expected.to eq 'hello' }
+    end
+
+    context 'the second request' do
+      before do
+        make_request
+      end
+
+      it { is_expected.to eq 'world' }
+    end
+  end
+
+  describe 'yielding env to stubs' do
+    subject { connection.get('http://foo.com/foo?a=1').body }
+
+    before do
+      stubs.get '/foo' do |env|
+        expect(env[:url].path).to eq '/foo'
+        expect(env[:url].host).to eq 'foo.com'
+        expect(env[:params]['a']).to eq '1'
+        expect(env[:request_headers]['Accept']).to eq 'text/plain'
+        [200, {}, 'a']
+      end
+
+      connection.headers['Accept'] = 'text/plain'
+    end
+
+    it { is_expected.to eq 'a' }
+  end
+
+  describe 'params parsing' do
+    subject { connection.get('http://foo.com/foo?a[b]=1').body }
+
+    context 'with default encoder' do
+      before do
+        stubs.get '/foo' do |env|
+          expect(env[:params]['a']['b']).to eq '1'
+          [200, {}, 'a']
+        end
+      end
+
+      it { is_expected.to eq 'a' }
+    end
+
+    context 'with nested encoder' do
+      before do
+        stubs.get '/foo' do |env|
+          expect(env[:params]['a']['b']).to eq '1'
+          [200, {}, 'a']
+        end
+
+        connection.options.params_encoder = Faraday::NestedParamsEncoder
+      end
+
+      it { is_expected.to eq 'a' }
+    end
+
+    context 'with flat encoder' do
+      before do
+        stubs.get '/foo' do |env|
+          expect(env[:params]['a[b]']).to eq '1'
+          [200, {}, 'a']
+        end
+
+        connection.options.params_encoder = Faraday::FlatParamsEncoder
+      end
+
+      it { is_expected.to eq 'a' }
+    end
+  end
+
+  describe 'raising an error if no stub was found' do
+    describe 'for request' do
+      subject(:request) { connection.get('/invalid') { [200, {}, []] } }
+
+      it { expect { request }.to raise_error described_class::Stubs::NotFound }
+    end
+
+    describe 'for specified host' do
+      subject(:request) { connection.get('http://domain.test/bait') }
+
+      it { expect { request }.to raise_error described_class::Stubs::NotFound }
+    end
+
+    describe 'for request without specified header' do
+      subject(:request) { connection.get('/yo') }
+
+      before do
+        stubs.get('/yo', 'X-HELLO' => 'hello') { [200, {}, 'a'] }
+      end
+
+      it { expect { request }.to raise_error described_class::Stubs::NotFound }
+    end
+  end
+
+  describe 'for request with non default params encoder' do
+    let(:connection) do
+      Faraday.new(request: { params_encoder: Faraday::FlatParamsEncoder }) do |builder|
+        builder.adapter :test, stubs
+      end
+    end
+    let(:stubs) do
+      described_class::Stubs.new do |stubs|
+        stubs.get('/path?a=x&a=y&a=z') { [200, {}, 'a'] }
+      end
+    end
+
+    context 'when all flat param values are correctly set' do
+      subject(:request) { connection.get('/path?a=x&a=y&a=z') }
+
+      it { expect(request.status).to eq 200 }
+    end
+
+    shared_examples 'raise NotFound when params do not satisfy the flat param values' do |params|
+      subject(:request) { connection.get('/path', params) }
+
+      context "with #{params.inspect}" do
+        it { expect { request }.to raise_error described_class::Stubs::NotFound }
+      end
+    end
+
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { a: %w[x] }
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { a: %w[x y] }
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { a: %w[x z y] } # NOTE: The order of the value is also compared.
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { b: %w[x y z] }
+  end
+
+  describe 'strict_mode' do
+    let(:stubs) do
+      described_class::Stubs.new(strict_mode: true) do |stubs|
+        stubs.get('/strict?a=12&b=xy', 'Authorization' => 'Bearer m_ck', 'X-C' => 'hello') { [200, {}, 'a'] }
+        stubs.get('/with_user_agent?a=12&b=xy', authorization: 'Bearer m_ck', 'User-Agent' => 'My Agent') { [200, {}, 'a'] }
+      end
+    end
+
+    context 'when params and headers are exactly set' do
+      subject(:request) { connection.get('/strict', { a: '12', b: 'xy' }, { authorization: 'Bearer m_ck', x_c: 'hello' }) }
+
+      it { expect(request.status).to eq 200 }
+    end
+
+    context 'when params and headers are exactly set with a custom user agent' do
+      subject(:request) { connection.get('/with_user_agent', { a: '12', b: 'xy' }, { authorization: 'Bearer m_ck', 'User-Agent' => 'My Agent' }) }
+
+      it { expect(request.status).to eq 200 }
+    end
+
+    shared_examples 'raise NotFound when params do not satisfy the strict check' do |params|
+      subject(:request) { connection.get('/strict', params, { 'Authorization' => 'Bearer m_ck', 'X-C' => 'hello' }) }
+
+      context "with #{params.inspect}" do
+        it { expect { request }.to raise_error described_class::Stubs::NotFound }
+      end
+    end
+
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '12' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { b: 'xy' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '123', b: 'xy' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '12', b: 'xyz' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '12', b: 'xy', c: 'hello' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { additional: 'special', a: '12', b: 'xy', c: 'hello' }
+
+    shared_examples 'raise NotFound when headers do not satisfy the strict check' do |path, headers|
+      subject(:request) { connection.get(path, { a: 12, b: 'xy' }, headers) }
+
+      context "with #{headers.inspect}" do
+        it { expect { request }.to raise_error described_class::Stubs::NotFound }
+      end
+    end
+
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { 'X-C' => 'hello' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'Hi' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Basic m_ck', 'x-c': 'hello' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello', x_special: 'special' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'Unknown' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'My Agent', x_special: 'special' }
+
+    context 'when strict_mode is disabled' do
+      before do
+        stubs.strict_mode = false
+      end
+
+      shared_examples 'does not raise NotFound even when params do not satisfy the strict check' do |params|
+        subject(:request) { connection.get('/strict', params, { 'Authorization' => 'Bearer m_ck', 'X-C' => 'hello' }) }
+
+        context "with #{params.inspect}" do
+          it { expect(request.status).to eq 200 }
+        end
+      end
+
+      it_behaves_like 'does not raise NotFound even when params do not satisfy the strict check', { a: '12', b: 'xy' }
+      it_behaves_like 'does not raise NotFound even when params do not satisfy the strict check', { a: '12', b: 'xy', c: 'hello' }
+      it_behaves_like 'does not raise NotFound even when params do not satisfy the strict check', { additional: 'special', a: '12', b: 'xy', c: 'hello' }
+
+      shared_examples 'does not raise NotFound even when headers do not satisfy the strict check' do |path, headers|
+        subject(:request) { connection.get(path, { a: 12, b: 'xy' }, headers) }
+
+        context "with #{headers.inspect}" do
+          it { expect(request.status).to eq 200 }
+        end
+      end
+
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello', x_special: 'special' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello', user_agent: 'Special Agent' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'My Agent' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'My Agent', x_special: 'special' }
+    end
+  end
+end

data/spec/faraday/connection_spec.rb

@@ -18,6 +18,13 @@ shared_examples 'initializer with url' do
     it { expect(subject.path_prefix).to eq('/fish') }
     it { expect(subject.params).to eq('a' => '1') }
   end
+
+  context 'with IPv6 address' do
+    let(:address) { 'http://[::1]:85/' }
+
+    it { expect(subject.host).to eq('[::1]') }
+    it { expect(subject.port).to eq(85) }
+  end
 end
 
 shared_examples 'default connection options' do
@@ -246,6 +253,13 @@ RSpec.describe Faraday::Connection do
       expect(uri.path).to eq('/sake.html')
     end
 
+    it 'always returns new URI instance' do
+      conn.url_prefix = 'http://sushi.com'
+      uri1 = conn.build_exclusive_url(nil)
+      uri2 = conn.build_exclusive_url(nil)
+      expect(uri1).not_to equal(uri2)
+    end
+
     context 'with url_prefixed connection' do
       let(:url) { 'http://sushi.com/sushi/' }
 
@@ -270,6 +284,29 @@ RSpec.describe Faraday::Connection do
         expect(uri.to_s).to eq('http://sushi.com/sake/')
       end
     end
+
+    context 'with colon in path' do
+      let(:url) { 'http://service.com' }
+
+      it 'joins url to base when used absolute path' do
+        conn = Faraday.new(url: url)
+        uri = conn.build_exclusive_url('/service:search?limit=400')
+        expect(uri.to_s).to eq('http://service.com/service:search?limit=400')
+      end
+
+      it 'joins url to base when used relative path' do
+        conn = Faraday.new(url: url)
+        uri = conn.build_exclusive_url('service:search?limit=400')
+        expect(uri.to_s).to eq('http://service.com/service%3Asearch?limit=400')
+      end
+
+      it 'joins url to base when used with path prefix' do
+        conn = Faraday.new(url: url)
+        conn.path_prefix = '/api'
+        uri = conn.build_exclusive_url('service:search?limit=400')
+        expect(uri.to_s).to eq('http://service.com/api/service%3Asearch?limit=400')
+      end
+    end
   end
 
   describe '#build_url' do
@@ -412,6 +449,14 @@ RSpec.describe Faraday::Connection do
       end
     end
 
+    it 'allows when url in no proxy list with url_prefix' do
+      with_env 'http_proxy' => 'http://proxy.com', 'no_proxy' => 'example.com' do
+        conn = Faraday::Connection.new
+        conn.url_prefix = 'http://example.com'
+        expect(conn.proxy).to be_nil
+      end
+    end
+
     it 'allows when prefixed url is not in no proxy list' do
       with_env 'http_proxy' => 'http://proxy.com', 'no_proxy' => 'example.com' do
         conn = Faraday::Connection.new('http://prefixedexample.com')

data/spec/faraday/deprecate_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::DeprecatedClass do
+  class SampleClass < StandardError
+    attr_accessor :foo
+
+    def initialize(foo = nil)
+      @foo = foo || :foo
+    end
+  end
+
+  SampleDeprecatedClass = Faraday::DeprecatedClass.proxy_class(SampleClass)
+
+  it 'does not raise error for deprecated classes but prints an error message' do
+    error_message, foobar = with_warn_squelching { SampleDeprecatedClass.new(:foo_bar) }
+    expect(foobar).to be_a(SampleClass)
+    expect(foobar.foo).to eq(:foo_bar)
+    expect(error_message).to match(
+      Regexp.new(
+        'NOTE: SampleDeprecatedClass.new is deprecated; '\
+        'use SampleClass.new instead. It will be removed in or after version 1.0'
+      )
+    )
+  end
+
+  it 'does not raise an error for inherited error-namespaced classes but prints an error message' do
+    error_message, = with_warn_squelching { Class.new(SampleDeprecatedClass) }
+
+    expect(error_message).to match(
+      Regexp.new(
+        'NOTE: Inheriting SampleDeprecatedClass is deprecated; '\
+        'use SampleClass instead. It will be removed in or after version 1.0'
+      )
+    )
+  end
+
+  it 'allows backward-compatible class to be subclassed' do
+    expect do
+      with_warn_squelching { Class.new(SampleDeprecatedClass) }
+    end.not_to raise_error
+  end
+
+  it 'allows rescuing of a current error with a deprecated error' do
+    expect { raise SampleClass, nil }.to raise_error(SampleDeprecatedClass)
+  end
+
+  it 'allows rescuing of a current error with a current error' do
+    expect { raise SampleClass, nil }.to raise_error(SampleClass)
+  end
+
+  it 'allows rescuing of a deprecated error with a deprecated error' do
+    expect { raise SampleDeprecatedClass, nil }.to raise_error(SampleDeprecatedClass)
+  end
+
+  it 'allows rescuing of a deprecated error with a current error' do
+    expect { raise SampleDeprecatedClass, nil }.to raise_error(SampleClass)
+  end
+
+  describe 'match behavior' do
+    class SampleDeprecatedClassA < SampleDeprecatedClass; end
+    class SampleDeprecatedClassB < SampleDeprecatedClass; end
+
+    class SampleDeprecatedClassAX < SampleDeprecatedClassA; end
+
+    class SampleClassA < SampleClass; end
+
+    describe 'undeprecated class' do
+      it 'is === to instance of deprecated class' do
+        expect(SampleDeprecatedClass.new.is_a?(SampleClass)).to be true
+      end
+
+      it 'is === to instance of subclass of deprecated class' do
+        expect(SampleDeprecatedClassA.new.is_a?(SampleClass)).to be true
+      end
+
+      it 'is === to instance of subclass of subclass of deprecated class' do
+        expect(SampleDeprecatedClassAX.new.is_a?(SampleClass)).to be true
+      end
+    end
+
+    describe 'subclass of undeprecated class' do
+      it 'is not === to instance of undeprecated class' do
+        expect(SampleClass.new.is_a?(SampleClassA)).to be false
+      end
+
+      it 'is not === to instance of deprecated class' do
+        expect(SampleDeprecatedClass.new.is_a?(SampleClassA)).to be false
+      end
+    end
+
+    describe 'deprecated class' do
+      it 'is === to instance of undeprecated class' do
+        expect(SampleDeprecatedClass.new.is_a?(SampleClass)).to be true
+      end
+
+      it 'is === to instance of subclass of undeprecated class' do
+        expect(SampleClassA.superclass == SampleDeprecatedClass.superclass).to be true
+      end
+
+      it 'is === to instance of subclass of deprecated class' do
+        expect(SampleDeprecatedClassA.new.is_a?(SampleDeprecatedClass)).to be true
+      end
+
+      it 'is === to instance of subclass of subclass of deprecated class' do
+        expect(SampleDeprecatedClassAX.new.is_a?(SampleDeprecatedClass)).to be true
+      end
+    end
+
+    describe 'subclass of deprecated class' do
+      it 'is not === to instance of subclass of undeprecated class' do
+        expect(SampleClass.new.is_a?(SampleDeprecatedClassA)).to be false
+      end
+
+      it 'is not === to instance of another subclass of deprecated class' do
+        expect(SampleDeprecatedClassB.new.is_a?(SampleDeprecatedClassA)).to be false
+      end
+
+      it 'is === to instance of its subclass' do
+        expect(SampleDeprecatedClassAX.new.is_a?(SampleDeprecatedClassA)).to be true
+      end
+
+      it 'is === to instance of deprecated class' do
+        expect(SampleDeprecatedClassB.new.is_a?(SampleDeprecatedClass)).to be true
+      end
+    end
+
+    describe 'subclass of subclass of deprecated class' do
+      it 'is not === to instance of subclass of another subclass of deprecated class' do
+        expect(SampleDeprecatedClassB.new.is_a?(SampleDeprecatedClassAX)).to be false
+      end
+
+      it 'is not === to instance of its superclass' do
+        expect(SampleDeprecatedClass.new.is_a?(SampleDeprecatedClassA)).to be false
+      end
+    end
+  end
+
+  def with_warn_squelching
+    stderr_catcher = StringIO.new
+    original_stderr = $stderr
+    $stderr = stderr_catcher
+    result = yield if block_given?
+    [stderr_catcher.tap(&:rewind).string, result]
+  ensure
+    $stderr = original_stderr
+  end
+end

data/spec/faraday/error_spec.rb

@@ -13,6 +13,7 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.message).to eq(exception.message) }
       it { expect(subject.backtrace).to eq(exception.backtrace) }
       it { expect(subject.inspect).to eq('#<Faraday::ClientError wrapped=#<RuntimeError: test>>') }
+      it { expect(subject.response_status).to be_nil }
     end
 
     context 'with response hash' do
@@ -22,6 +23,7 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.response).to eq(exception) }
       it { expect(subject.message).to eq('the server responded with status 400') }
       it { expect(subject.inspect).to eq('#<Faraday::ClientError response={:status=>400}>') }
+      it { expect(subject.response_status).to eq(400) }
     end
 
     context 'with string' do
@@ -31,6 +33,7 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.response).to be_nil }
       it { expect(subject.message).to eq('custom message') }
       it { expect(subject.inspect).to eq('#<Faraday::ClientError #<Faraday::ClientError: custom message>>') }
+      it { expect(subject.response_status).to be_nil }
     end
 
     context 'with anything else #to_s' do
@@ -40,6 +43,18 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.response).to be_nil }
       it { expect(subject.message).to eq('["error1", "error2"]') }
       it { expect(subject.inspect).to eq('#<Faraday::ClientError #<Faraday::ClientError: ["error1", "error2"]>>') }
+      it { expect(subject.response_status).to be_nil }
+    end
+
+    context 'with exception string and response hash' do
+      let(:exception) { 'custom message' }
+      let(:response) { { status: 400 } }
+
+      it { expect(subject.wrapped_exception).to be_nil }
+      it { expect(subject.response).to eq(response) }
+      it { expect(subject.message).to eq('custom message') }
+      it { expect(subject.inspect).to eq('#<Faraday::ClientError response={:status=>400}>') }
+      it { expect(subject.response_status).to eq(400) }
     end
   end
 end

data/spec/faraday/middleware_spec.rb

@@ -2,23 +2,49 @@
 
 RSpec.describe Faraday::Middleware do
   subject { described_class.new(app) }
+  let(:app) { double }
+
+  describe 'options' do
+    context 'when options are passed to the middleware' do
+      subject { described_class.new(app, options) }
+      let(:options) { { field: 'value' } }
+
+      it 'accepts options when initialized' do
+        expect(subject.options[:field]).to eq('value')
+      end
+    end
+  end
+
+  describe '#on_request' do
+    subject do
+      Class.new(described_class) do
+        def on_request(env)
+          # do nothing
+        end
+      end.new(app)
+    end
+
+    it 'is called by #call' do
+      expect(app).to receive(:call).and_return(app)
+      expect(app).to receive(:on_complete)
+      is_expected.to receive(:call).and_call_original
+      is_expected.to receive(:on_request)
+      subject.call(double)
+    end
+  end
 
   describe '#close' do
     context "with app that doesn't support \#close" do
-      let(:app) { double }
-
       it 'should issue warning' do
-        expect(subject).to receive(:warn)
+        is_expected.to receive(:warn)
         subject.close
       end
     end
 
     context "with app that supports \#close" do
-      let(:app) { double }
-
       it 'should issue warning' do
         expect(app).to receive(:close)
-        expect(subject).to_not receive(:warn)
+        is_expected.to_not receive(:warn)
         subject.close
       end
     end