color_me_shop 1.0.0 → 1.1.0

data/vendor/bundle/ruby/2.5.0/gems/vcr-3.0.3/spec/lib/vcr/structs_spec.rb

@@ -1,732 +0,0 @@
-# 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
-