dwolla_swagger 1.0.5 → 1.0.6

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/spec/vcr/structs_spec.rb

@@ -0,0 +1,732 @@
+# encoding: UTF-8
+
+require 'support/ruby_interpreter'
+
+require 'yaml'
+require 'vcr/structs'
+require 'vcr/errors'
+require 'zlib'
+require 'stringio'
+require 'support/limited_uri'
+require 'support/configuration_stubbing'
+
+shared_examples_for "a header normalizer" do
+  let(:instance) do
+    with_headers('Some_Header' => 'value1', 'aNother' => ['a', 'b'], 'third' => [], 'fourth' => nil)
+  end
+
+  it 'ensures header keys are serialized to yaml as raw strings' do
+    key = 'my-key'
+    key.instance_variable_set(:@foo, 7)
+    instance = with_headers(key => ['value1'])
+    expect(YAML.dump(instance.headers)).to eq(YAML.dump('my-key' => ['value1']))
+  end
+
+  it 'ensures header values are serialized to yaml as raw strings' do
+    value = 'my-value'
+    value.instance_variable_set(:@foo, 7)
+    instance = with_headers('my-key' => [value])
+    expect(YAML.dump(instance.headers)).to eq(YAML.dump('my-key' => ['my-value']))
+  end
+
+  it 'handles nested arrays' do
+    accept_encoding = [["gzip", "1.0"], ["deflate", "1.0"], ["sdch", "1.0"]]
+    instance = with_headers('accept-encoding' => accept_encoding)
+    expect(instance.headers['accept-encoding']).to eq(accept_encoding)
+  end
+
+  it 'handles nested arrays with floats' do
+    accept_encoding = [["gzip", 1.0], ["deflate", 1.0], ["sdch", 1.0]]
+    instance = with_headers('accept-encoding' => accept_encoding)
+    expect(instance.headers['accept-encoding']).to eq(accept_encoding)
+  end
+end
+
+shared_examples_for "a body normalizer" do
+  it "ensures the body is serialized to yaml as a raw string" do
+    body = "My String"
+    body.instance_variable_set(:@foo, 7)
+    expect(YAML.dump(instance(body).body)).to eq(YAML.dump("My String"))
+  end
+
+  it 'converts nil to a blank string' do
+    expect(instance(nil).body).to eq("")
+  end
+
+  it 'raises an error if given another type of object as the body' do
+    expect {
+      instance(:a => "hash")
+    }.to raise_error(ArgumentError)
+  end
+end
+
+module VCR
+  describe HTTPInteraction do
+    include_context "configuration stubbing"
+    before { allow(config).to receive(:uri_parser) { LimitedURI } }
+
+    if ''.respond_to?(:encoding)
+      def body_hash(key, value)
+        { key => value, 'encoding' => 'UTF-8' }
+      end
+    else
+      def body_hash(key, value)
+        { key => value }
+      end
+    end
+
+    describe "#recorded_at" do
+      let(:now) { Time.now }
+
+      it 'is initialized to the current time' do
+        allow(Time).to receive(:now).and_return(now)
+        expect(VCR::HTTPInteraction.new.recorded_at).to eq(now)
+      end
+    end
+
+    let(:status)      { ResponseStatus.new(200, "OK") }
+    let(:response)    { Response.new(status, { "foo" => ["bar"] }, "res body", "1.1") }
+    let(:request)     { Request.new(:get, "http://foo.com/", "req body", { "bar" => ["foo"] }) }
+    let(:recorded_at) { Time.utc(2011, 5, 4, 12, 30) }
+    let(:interaction) { HTTPInteraction.new(request, response, recorded_at) }
+
+    describe ".from_hash" do
+      let(:hash) do
+        {
+          'request' => {
+            'method'  => 'get',
+            'uri'     => 'http://foo.com/',
+            'body'    => body_hash('string', 'req body'),
+            'headers' => { "bar" => ["foo"] }
+          },
+          'response' => {
+            'status'       => {
+              'code'       => 200,
+              'message'    => 'OK'
+            },
+            'headers'      => { "foo"     => ["bar"] },
+            'body'         => body_hash('string', 'res body'),
+            'http_version' => '1.1'
+          },
+          'recorded_at' => "Wed, 04 May 2011 12:30:00 GMT"
+        }
+      end
+
+      it 'constructs an HTTP interaction from the given hash' do
+        expect(HTTPInteraction.from_hash(hash)).to eq(interaction)
+      end
+
+      it 'initializes the recorded_at timestamp from the hash' do
+        expect(HTTPInteraction.from_hash(hash).recorded_at).to eq(recorded_at)
+      end
+
+      it 'initializes the response adapter_metadata from the hash if it is included' do
+        hash['response']['adapter_metadata'] = { 'foo' => 12 }
+        interaction = HTTPInteraction.from_hash(hash)
+        expect(interaction.response.adapter_metadata).to eq("foo" => 12)
+      end
+
+      it 'works when the response adapter_metadata is missing' do
+        expect(hash['response'].keys).not_to include('adapter_metadata')
+        interaction = HTTPInteraction.from_hash(hash)
+        expect(interaction.response.adapter_metadata).to eq({})
+      end
+
+      it 'uses a blank request when the hash lacks one' do
+        hash.delete('request')
+        i = HTTPInteraction.from_hash(hash)
+        expect(i.request).to eq(Request.new)
+      end
+
+      it 'uses a blank response when the hash lacks one' do
+        hash.delete('response')
+        i = HTTPInteraction.from_hash(hash)
+        expect(i.response).to eq(Response.new(ResponseStatus.new))
+      end
+
+      it 'decodes the base64 body string' do
+        hash['request']['body'] = body_hash('base64_string', Base64.encode64('req body'))
+        hash['response']['body'] = body_hash('base64_string', Base64.encode64('res body'))
+
+        i = HTTPInteraction.from_hash(hash)
+        expect(i.request.body).to eq('req body')
+        expect(i.response.body).to eq('res body')
+      end
+
+      if ''.respond_to?(:encoding)
+        it 'force encodes the decoded base64 string as the original encoding' do
+          string = "café"
+          string.force_encoding("US-ASCII")
+          expect(string).not_to be_valid_encoding
+
+          hash['request']['body']  = { 'base64_string' => Base64.encode64(string.dup), 'encoding' => 'US-ASCII' }
+          hash['response']['body'] = { 'base64_string' => Base64.encode64(string.dup), 'encoding' => 'US-ASCII' }
+
+          i = HTTPInteraction.from_hash(hash)
+          expect(i.request.body.encoding.name).to eq("US-ASCII")
+          expect(i.response.body.encoding.name).to eq("US-ASCII")
+          expect(i.request.body.bytes.to_a).to eq(string.bytes.to_a)
+          expect(i.response.body.bytes.to_a).to eq(string.bytes.to_a)
+          expect(i.request.body).not_to be_valid_encoding
+          expect(i.response.body).not_to be_valid_encoding
+        end
+
+        it 'does not attempt to force encode the decoded base64 string when there is no encoding given (i.e. if the cassette was recorded on ruby 1.8)' do
+          hash['request']['body']  = { 'base64_string' => Base64.encode64('foo') }
+
+          i = HTTPInteraction.from_hash(hash)
+          expect(i.request.body).to eq('foo')
+          expect(i.request.body.encoding.name).to eq("ASCII-8BIT")
+        end
+
+        it 'tries to encode strings to the original encoding' do
+          hash['request']['body']  = { 'string' => "abc", 'encoding' => 'ISO-8859-1' }
+          hash['response']['body'] = { 'string' => "abc", 'encoding' => 'ISO-8859-1' }
+
+          i = HTTPInteraction.from_hash(hash)
+          expect(i.request.body).to eq("abc")
+          expect(i.response.body).to eq("abc")
+          expect(i.request.body.encoding.name).to eq("ISO-8859-1")
+          expect(i.response.body.encoding.name).to eq("ISO-8859-1")
+        end
+
+        it 'does not attempt to encode the string when there is no encoding given (i.e. if the cassette was recorded on ruby 1.8)' do
+          string = 'foo'
+          string.force_encoding("ISO-8859-1")
+          hash['request']['body']  = { 'string' => string }
+
+          i = HTTPInteraction.from_hash(hash)
+          expect(i.request.body).to eq('foo')
+          expect(i.request.body.encoding.name).to eq("ISO-8859-1")
+        end
+
+        it 'force encodes to ASCII-8BIT (since it just means "no encoding" or binary)' do
+          string = "\u00f6"
+          string.encode("UTF-8")
+          expect(string).to be_valid_encoding
+          hash['request']['body']  = { 'string' => string, 'encoding' => 'ASCII-8BIT' }
+
+          expect(Request).not_to receive(:warn)
+          i = HTTPInteraction.from_hash(hash)
+          expect(i.request.body).to eq(string)
+          expect(i.request.body.bytes.to_a).to eq(string.bytes.to_a)
+          expect(i.request.body.encoding.name).to eq("ASCII-8BIT")
+        end
+
+        context 'when the string cannot be encoded as the original encoding' do
+          def verify_encoding_error
+            expect { "\xFAbc".encode("ISO-8859-1") }.to raise_error(EncodingError)
+          end
+
+          before do
+            allow(Request).to receive(:warn)
+            allow(Response).to receive(:warn)
+
+            hash['request']['body']  = { 'string' => "\xFAbc", 'encoding' => 'ISO-8859-1' }
+            hash['response']['body']  = { 'string' => "\xFAbc", 'encoding' => 'ISO-8859-1' }
+
+            verify_encoding_error
+          end
+
+          it 'does not force the encoding' do
+            i = HTTPInteraction.from_hash(hash)
+            expect(i.request.body).to eq("\xFAbc")
+            expect(i.response.body).to eq("\xFAbc")
+            expect(i.request.body.encoding.name).not_to eq("ISO-8859-1")
+            expect(i.response.body.encoding.name).not_to eq("ISO-8859-1")
+          end
+
+          it 'prints a warning and informs users of the :preserve_exact_body_bytes option' do
+            expect(Request).to receive(:warn).with(/ISO-8859-1.*preserve_exact_body_bytes/)
+            expect(Response).to receive(:warn).with(/ISO-8859-1.*preserve_exact_body_bytes/)
+
+            HTTPInteraction.from_hash(hash)
+          end
+        end
+      end
+    end
+
+    describe "#to_hash" do
+      include_context "configuration stubbing"
+
+      before(:each) do
+        allow(config).to receive(:preserve_exact_body_bytes_for?).and_return(false)
+        allow(config).to receive(:uri_parser).and_return(URI)
+      end
+
+      let(:hash) { interaction.to_hash }
+
+      it 'returns a nested hash containing all of the pertinent details' do
+        expect(hash.keys).to match_array %w[ request response recorded_at ]
+
+        expect(hash['recorded_at']).to eq(interaction.recorded_at.httpdate)
+
+        expect(hash['request']).to eq({
+          'method'  => 'get',
+          'uri'     => 'http://foo.com/',
+          'body'    => body_hash('string', 'req body'),
+          'headers' => { "bar" => ["foo"] }
+        })
+
+        expect(hash['response']).to eq({
+          'status'       => {
+            'code'       => 200,
+            'message'    => 'OK'
+          },
+          'headers'      => { "foo"     => ["bar"] },
+          'body'         => body_hash('string', 'res body'),
+          'http_version' => '1.1'
+        })
+      end
+
+      it 'includes the response adapter metadata when it is not empty' do
+        interaction.response.adapter_metadata['foo'] = 17
+        expect(hash['response']['adapter_metadata']).to eq('foo' => 17)
+      end
+
+      it 'does not include the response adapter metadata when it is empty' do
+        expect(interaction.response.adapter_metadata).to eq({})
+        expect(hash['response'].keys).not_to include('adapter_metadata')
+      end
+
+      context "when the body is extended with a module and some state" do
+        it 'serializes to YAML w/o the extra state' do
+          interaction.request.body.extend Module.new { attr_accessor :foo }
+          interaction.response.body.extend Module.new { attr_accessor :foo }
+          interaction.request.body.foo = 98765
+          interaction.response.body.foo = 98765
+
+          expect(YAML.dump(interaction.to_hash)).not_to include("98765")
+        end
+      end
+
+      it 'encodes the body as base64 when the configuration is so set' do
+        allow(config).to receive(:preserve_exact_body_bytes_for?).and_return(true)
+        expect(hash['request']['body']).to eq(body_hash('base64_string', Base64.encode64('req body')))
+        expect(hash['response']['body']).to eq(body_hash('base64_string', Base64.encode64('res body')))
+      end
+
+      it "sets the string's original encoding", :if => ''.respond_to?(:encoding) do
+        interaction.request.body.force_encoding('ISO-8859-10')
+        interaction.response.body.force_encoding('ASCII-8BIT')
+
+        expect(hash['request']['body']['encoding']).to eq('ISO-8859-10')
+        expect(hash['response']['body']['encoding']).to eq('ASCII-8BIT')
+      end
+
+      def assert_yielded_keys(hash, *keys)
+        yielded_keys = []
+        hash.each { |k, v| yielded_keys << k }
+        expect(yielded_keys).to eq(keys)
+      end
+
+      it 'yields the entries in the expected order so the hash can be serialized in that order' do
+        assert_yielded_keys hash, 'request', 'response', 'recorded_at'
+        assert_yielded_keys hash['request'], 'method', 'uri', 'body', 'headers'
+        assert_yielded_keys hash['response'], 'status', 'headers', 'body', 'http_version'
+        assert_yielded_keys hash['response']['status'], 'code', 'message'
+      end
+
+      it 'yields `adapter_metadata` if it has any data' do
+        interaction.response.adapter_metadata['foo'] = 17
+        assert_yielded_keys hash['response'], 'status', 'headers', 'body', 'http_version', 'adapter_metadata'
+      end
+    end
+
+    describe "#parsed_uri" do
+      before :each do
+        allow(uri_parser).to receive(:parse).and_return(uri)
+        allow(config).to receive(:uri_parser).and_return(uri_parser)
+      end
+
+      let(:uri_parser){ double('parser') }
+      let(:uri){ double('uri').as_null_object }
+
+      it "parses the uri using the current uri_parser" do
+        expect(uri_parser).to receive(:parse).with(request.uri)
+        request.parsed_uri
+      end
+
+      it "returns the parsed uri" do
+        expect(request.parsed_uri).to eq uri
+      end
+    end
+  end
+
+  describe HTTPInteraction::HookAware do
+    include_context "configuration stubbing"
+
+    before do
+      allow(config).to receive(:uri_parser) { LimitedURI }
+    end
+
+    let(:response_status) { VCR::ResponseStatus.new(200, "OK foo") }
+    let(:body) { "The body foo this is (foo-Foo)" }
+    let(:headers) do {
+      'x-http-foo' => ['bar23', '23foo'],
+      'x-http-bar' => ['foo23', '18']
+    } end
+
+    let(:response) do
+      VCR::Response.new(
+        response_status,
+        headers.dup,
+        body.dup,
+        '1.1'
+      )
+    end
+
+    let(:request) do
+      VCR::Request.new(
+        :get,
+        'http://example-foo.com:80/foo/',
+        body.dup,
+        headers.dup
+      )
+    end
+
+    let(:interaction) { VCR::HTTPInteraction.new(request, response) }
+    subject { HTTPInteraction::HookAware.new(interaction) }
+
+    describe '#ignored?' do
+      it 'returns false by default' do
+        should_not be_ignored
+      end
+
+      it 'returns true when #ignore! has been called' do
+        subject.ignore!
+        should be_ignored
+      end
+    end
+
+    describe '#filter!' do
+      let(:filtered) { subject.filter!('foo', 'AAA') }
+
+      it 'does nothing when given a blank argument' do
+        expect {
+          subject.filter!(nil, 'AAA')
+          subject.filter!('foo', nil)
+          subject.filter!("", 'AAA')
+          subject.filter!('foo', "")
+        }.not_to change { interaction }
+      end
+
+      [:request, :response].each do |part|
+        it "replaces the sensitive text in the #{part} header keys and values" do
+          expect(filtered.send(part).headers).to eq({
+            'x-http-AAA' => ['bar23', '23AAA'],
+            'x-http-bar' => ['AAA23', '18']
+          })
+        end
+
+        it "replaces the sensitive text in the #{part} body" do
+          expect(filtered.send(part).body).to eq("The body AAA this is (AAA-Foo)")
+        end
+      end
+
+      it 'replaces the sensitive text in the response status' do
+        expect(filtered.response.status.message).to eq('OK AAA')
+      end
+
+      it 'replaces sensitive text in the request URI' do
+        expect(filtered.request.uri).to eq('http://example-AAA.com/AAA/')
+      end
+
+      it 'handles numbers (such as the port) properly' do
+        request.uri = "http://foo.com:9000/bar"
+        subject.filter!(9000, "<PORT>")
+        expect(request.uri).to eq("http://foo.com:<PORT>/bar")
+      end
+    end
+  end
+
+  describe Request::Typed do
+    [:uri, :method, :headers, :body].each do |method|
+      it "delegates ##{method} to the request" do
+        request = double(method => "delegated value")
+        expect(Request::Typed.new(request, :type).send(method)).to eq("delegated value")
+      end
+    end
+
+    describe "#type" do
+      it 'returns the initialized type' do
+        expect(Request::Typed.new(double, :ignored).type).to be(:ignored)
+      end
+    end
+
+    valid_types = [:ignored, :stubbed_by_vcr, :externally_stubbed, :recordable, :unhandled]
+    valid_types.each do |type|
+      describe "##{type}?" do
+        it "returns true if the type is set to :#{type}" do
+          expect(Request::Typed.new(double, type).send("#{type}?")).to be true
+        end
+
+        it "returns false if the type is set to :other" do
+          expect(Request::Typed.new(double, :other).send("#{type}?")).to be false
+        end
+      end
+    end
+
+    describe "#real?" do
+      real_types = [:ignored, :recordable]
+      real_types.each do |type|
+        it "returns true if the type is set to :#{type}" do
+          expect(Request::Typed.new(double, type)).to be_real
+        end
+      end
+
+      (valid_types - real_types).each do |type|
+        it "returns false if the type is set to :#{type}" do
+          expect(Request::Typed.new(double, type)).not_to be_real
+        end
+      end
+    end
+
+    describe "#stubbed?" do
+      stubbed_types = [:externally_stubbed, :stubbed_by_vcr]
+      stubbed_types.each do |type|
+        it "returns true if the type is set to :#{type}" do
+          expect(Request::Typed.new(double, type)).to be_stubbed
+        end
+      end
+
+      (valid_types - stubbed_types).each do |type|
+        it "returns false if the type is set to :#{type}" do
+          expect(Request::Typed.new(double, type)).not_to be_stubbed
+        end
+      end
+    end
+  end
+
+  describe Request do
+    include_context "configuration stubbing"
+
+    before do
+      allow(config).to receive(:uri_parser) { LimitedURI }
+    end
+
+    describe '#method' do
+      subject { VCR::Request.new(:get) }
+
+      context 'when given no arguments' do
+        it 'returns the HTTP method' do
+          expect(subject.method).to eq(:get)
+        end
+      end
+
+      context 'when given an argument' do
+        it 'returns the method object for the named method' do
+          m = subject.method(:class)
+          expect(m).to be_a(Method)
+          expect(m.call).to eq(described_class)
+        end
+      end
+
+      it 'gets normalized to a lowercase symbol' do
+        expect(VCR::Request.new("GET").method).to eq(:get)
+        expect(VCR::Request.new(:GET).method).to eq(:get)
+        expect(VCR::Request.new(:get).method).to eq(:get)
+        expect(VCR::Request.new("get").method).to eq(:get)
+      end
+    end
+
+    describe "#uri" do
+      def uri_for(uri)
+        VCR::Request.new(:get, uri).uri
+      end
+
+      it 'removes the default http port' do
+        expect(uri_for("http://foo.com:80/bar")).to eq("http://foo.com/bar")
+      end
+
+      it 'removes the default https port' do
+        expect(uri_for("https://foo.com:443/bar")).to eq("https://foo.com/bar")
+      end
+
+      it 'does not remove a non-standard http port' do
+        expect(uri_for("http://foo.com:81/bar")).to eq("http://foo.com:81/bar")
+      end
+
+      it 'does not remove a non-standard https port' do
+        expect(uri_for("https://foo.com:442/bar")).to eq("https://foo.com:442/bar")
+      end
+    end
+
+    describe Request::FiberAware do
+      subject { Request::FiberAware.new(Request.new) }
+
+      it 'adds a #proceed method that yields in a fiber' do
+        fiber = Fiber.new do |request|
+          request.proceed
+          :done
+        end
+
+        expect(fiber.resume(subject)).to be_nil
+        expect(fiber.resume).to eq(:done)
+      end
+
+      it 'can be cast to a proc' do
+        expect(Fiber).to receive(:yield)
+        lambda(&subject).call
+      end
+    end if RUBY_VERSION > '1.9'
+
+    it_behaves_like 'a header normalizer' do
+      def with_headers(headers)
+        described_class.new(:get, 'http://example.com/', nil, headers)
+      end
+    end
+
+    it_behaves_like 'a body normalizer' do
+      def instance(body)
+        described_class.new(:get, 'http://example.com/', body, {})
+      end
+    end
+  end
+
+  describe Response do
+    it_behaves_like 'a header normalizer' do
+      def with_headers(headers)
+        described_class.new(:status, headers, nil, '1.1')
+      end
+    end
+
+    it_behaves_like 'a body normalizer' do
+      def instance(body)
+        described_class.new(:status, {}, body, '1.1')
+      end
+    end
+
+    describe "#adapter_metadata" do
+      it 'returns the hash given as the last #initialize argument' do
+        response = Response.new(
+          ResponseStatus.new(200, "OK"),
+          {}, "the body", "1.1",
+          { "meta" => "value" }
+        )
+
+        expect(response.adapter_metadata).to eq("meta" => "value")
+      end
+
+      it 'returns a blank hash when nil is passed to #initialize' do
+        response = Response.new(
+          ResponseStatus.new(200, "OK"),
+          {}, "the body", "1.1", nil
+        )
+
+        expect(response.adapter_metadata).to eq({})
+      end
+    end
+
+    describe '#update_content_length_header' do
+      %w[ content-length Content-Length ].each do |header|
+        context "for the #{header} header" do
+          define_method :instance do |body, content_length|
+            headers = { 'content-type' => 'text' }
+            headers.merge!(header => content_length) if content_length
+            described_class.new(VCR::ResponseStatus.new, headers, body)
+          end
+
+          it 'does nothing when the response lacks a content_length header' do
+            inst = instance('the body', nil)
+            expect {
+              inst.update_content_length_header
+            }.not_to change { inst.headers[header] }
+          end
+
+          it 'sets the content_length header to the response body length when the header is present' do
+            inst = instance('the body', '3')
+            expect {
+              inst.update_content_length_header
+            }.to change { inst.headers[header] }.from(['3']).to(['8'])
+          end
+
+          it 'sets the content_length header to 0 if the response body is nil' do
+            inst = instance(nil, '3')
+            expect {
+              inst.update_content_length_header
+            }.to change { inst.headers[header] }.from(['3']).to(['0'])
+          end
+
+          it 'sets the header according to RFC 2616 based on the number of bytes (not the number of characters)' do
+            inst = instance('aؼ', '2') # the second char is a double byte char
+            expect {
+              inst.update_content_length_header
+            }.to change { inst.headers[header] }.from(['2']).to(['3'])
+          end
+        end
+      end
+    end
+
+    describe '#decompress' do
+      %w[ content-encoding Content-Encoding ].each do |header|
+        context "for the #{header} header" do
+          define_method :instance do |body, content_encoding|
+            headers = { 'content-type' => 'text',
+                        'content-length' => body.bytesize.to_s }
+            headers[header] = content_encoding if content_encoding
+            described_class.new(VCR::ResponseStatus.new, headers, body)
+          end
+
+          let(:content) { 'The quick brown fox jumps over the lazy dog' }
+
+          it "does nothing when no compression" do
+            resp = instance('Hello', nil)
+            expect(resp).not_to be_compressed
+            expect {
+              expect(resp.decompress).to equal(resp)
+            }.to_not change { resp.headers['content-length'] }
+          end
+
+          it "does nothing when encoding is 'identity'" do
+            resp = instance('Hello', 'identity')
+            expect(resp).not_to be_compressed
+            expect {
+              expect(resp.decompress).to equal(resp)
+            }.to_not change { resp.headers['content-length'] }
+          end
+
+          it "raises error for unrecognized encoding" do
+            resp = instance('Hello', 'flabbergaster')
+            expect(resp).not_to be_compressed
+            expect { resp.decompress }.
+              to raise_error(Errors::UnknownContentEncodingError, 'unknown content encoding: flabbergaster')
+          end
+
+          it "unzips gzipped response" do
+            io = StringIO.new
+
+            writer = Zlib::GzipWriter.new(io)
+            writer << content
+            writer.close
+
+            gzipped = io.string
+            resp = instance(gzipped, 'gzip')
+            expect(resp).to be_compressed
+            expect {
+              expect(resp.decompress).to equal(resp)
+              expect(resp).not_to be_compressed
+              expect(resp.body).to eq(content)
+            }.to change { resp.headers['content-length'] }.
+              from([gzipped.bytesize.to_s]).
+              to([content.bytesize.to_s])
+          end
+
+          it "inflates deflated response" do
+            deflated = Zlib::Deflate.deflate(content)
+            resp = instance(deflated, 'deflate')
+            expect(resp).to be_compressed
+            expect {
+              expect(resp.decompress).to equal(resp)
+              expect(resp).not_to be_compressed
+              expect(resp.body).to eq(content)
+            }.to change { resp.headers['content-length'] }.
+              from([deflated.bytesize.to_s]).
+              to([content.bytesize.to_s])
+          end
+        end
+      end
+    end
+  end
+end
+