cocRb 0.1.0 → 0.1.2

data/.bundle/ruby/3.0.0/gems/faraday-1.4.1/spec/faraday/request/retry_spec.rb

@@ -1,242 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Request::Retry do
-  let(:calls) { [] }
-  let(:times_called) { calls.size }
-  let(:options) { [] }
-  let(:conn) do
-    Faraday.new do |b|
-      b.request :retry, *options
-
-      b.adapter :test do |stub|
-        %w[get post].each do |method|
-          stub.send(method, '/unstable') do |env|
-            calls << env.dup
-            env[:body] = nil # simulate blanking out response body
-            callback.call
-          end
-        end
-      end
-    end
-  end
-
-  context 'when an unexpected error happens' do
-    let(:callback) { -> { raise 'boom!' } }
-
-    before { expect { conn.get('/unstable') }.to raise_error(RuntimeError) }
-
-    it { expect(times_called).to eq(1) }
-
-    context 'and this is passed as a custom exception' do
-      let(:options) { [{ exceptions: StandardError }] }
-
-      it { expect(times_called).to eq(3) }
-    end
-  end
-
-  context 'when an expected error happens' do
-    let(:callback) { -> { raise Errno::ETIMEDOUT } }
-
-    before do
-      @started = Time.now
-      expect { conn.get('/unstable') }.to raise_error(Errno::ETIMEDOUT)
-    end
-
-    it { expect(times_called).to eq(3) }
-
-    context 'and legacy max_retry set to 1' do
-      let(:options) { [1] }
-
-      it { expect(times_called).to eq(2) }
-    end
-
-    context 'and legacy max_retry set to -9' do
-      let(:options) { [-9] }
-
-      it { expect(times_called).to eq(1) }
-    end
-
-    context 'and new max_retry set to 3' do
-      let(:options) { [{ max: 3 }] }
-
-      it { expect(times_called).to eq(4) }
-    end
-
-    context 'and new max_retry set to -9' do
-      let(:options) { [{ max: -9 }] }
-
-      it { expect(times_called).to eq(1) }
-    end
-
-    context 'and both max_retry and interval are set' do
-      let(:options) { [{ max: 2, interval: 0.1 }] }
-
-      it { expect(Time.now - @started).to be_within(0.04).of(0.2) }
-    end
-  end
-
-  context 'when no exception raised' do
-    let(:options) { [{ max: 1, retry_statuses: 429 }] }
-
-    before { conn.get('/unstable') }
-
-    context 'and response code is in retry_statuses' do
-      let(:callback) { -> { [429, {}, ''] } }
-
-      it { expect(times_called).to eq(2) }
-    end
-
-    context 'and response code is not in retry_statuses' do
-      let(:callback) { -> { [503, {}, ''] } }
-
-      it { expect(times_called).to eq(1) }
-    end
-  end
-
-  describe '#calculate_retry_interval' do
-    context 'with exponential backoff' do
-      let(:options) { { max: 5, interval: 0.1, backoff_factor: 2 } }
-      let(:middleware) { Faraday::Request::Retry.new(nil, options) }
-
-      it { expect(middleware.send(:calculate_retry_interval, 5)).to eq(0.1) }
-      it { expect(middleware.send(:calculate_retry_interval, 4)).to eq(0.2) }
-      it { expect(middleware.send(:calculate_retry_interval, 3)).to eq(0.4) }
-    end
-
-    context 'with exponential backoff and max_interval' do
-      let(:options) { { max: 5, interval: 0.1, backoff_factor: 2, max_interval: 0.3 } }
-      let(:middleware) { Faraday::Request::Retry.new(nil, options) }
-
-      it { expect(middleware.send(:calculate_retry_interval, 5)).to eq(0.1) }
-      it { expect(middleware.send(:calculate_retry_interval, 4)).to eq(0.2) }
-      it { expect(middleware.send(:calculate_retry_interval, 3)).to eq(0.3) }
-      it { expect(middleware.send(:calculate_retry_interval, 2)).to eq(0.3) }
-    end
-
-    context 'with exponential backoff and interval_randomness' do
-      let(:options) { { max: 2, interval: 0.1, interval_randomness: 0.05 } }
-      let(:middleware) { Faraday::Request::Retry.new(nil, options) }
-
-      it { expect(middleware.send(:calculate_retry_interval, 2)).to be_between(0.1, 0.105) }
-    end
-  end
-
-  context 'when method is not idempotent' do
-    let(:callback) { -> { raise Errno::ETIMEDOUT } }
-
-    before { expect { conn.post('/unstable') }.to raise_error(Errno::ETIMEDOUT) }
-
-    it { expect(times_called).to eq(1) }
-  end
-
-  describe 'retry_if option' do
-    let(:callback) { -> { raise Errno::ETIMEDOUT } }
-    let(:options) { [{ retry_if: @check }] }
-
-    it 'retries if retry_if block always returns true' do
-      body = { foo: :bar }
-      @check = ->(_, _) { true }
-      expect { conn.post('/unstable', body) }.to raise_error(Errno::ETIMEDOUT)
-      expect(times_called).to eq(3)
-      expect(calls.all? { |env| env[:body] == body }).to be_truthy
-    end
-
-    it 'does not retry if retry_if block returns false checking env' do
-      @check = ->(env, _) { env[:method] != :post }
-      expect { conn.post('/unstable') }.to raise_error(Errno::ETIMEDOUT)
-      expect(times_called).to eq(1)
-    end
-
-    it 'does not retry if retry_if block returns false checking exception' do
-      @check = ->(_, exception) { !exception.is_a?(Errno::ETIMEDOUT) }
-      expect { conn.post('/unstable') }.to raise_error(Errno::ETIMEDOUT)
-      expect(times_called).to eq(1)
-    end
-
-    it 'FilePart: should rewind files on retry' do
-      io = StringIO.new('Test data')
-      filepart = Faraday::FilePart.new(io, 'application/octet/stream')
-
-      rewound = 0
-      rewind = -> { rewound += 1 }
-
-      @check = ->(_, _) { true }
-      allow(filepart).to receive(:rewind, &rewind)
-      expect { conn.post('/unstable', file: filepart) }.to raise_error(Errno::ETIMEDOUT)
-      expect(times_called).to eq(3)
-      expect(rewound).to eq(2)
-    end
-
-    it 'UploadIO: should rewind files on retry' do
-      io = StringIO.new('Test data')
-      upload_io = Faraday::UploadIO.new(io, 'application/octet/stream')
-
-      rewound = 0
-      rewind = -> { rewound += 1 }
-
-      @check = ->(_, _) { true }
-      allow(upload_io).to receive(:rewind, &rewind)
-      expect { conn.post('/unstable', file: upload_io) }.to raise_error(Errno::ETIMEDOUT)
-      expect(times_called).to eq(3)
-      expect(rewound).to eq(2)
-    end
-
-    context 'when explicitly specifying methods to retry' do
-      let(:options) { [{ retry_if: @check, methods: [:post] }] }
-
-      it 'does not call retry_if for specified methods' do
-        @check = ->(_, _) { raise 'this should have never been called' }
-        expect { conn.post('/unstable') }.to raise_error(Errno::ETIMEDOUT)
-        expect(times_called).to eq(3)
-      end
-    end
-
-    context 'with empty list of methods to retry' do
-      let(:options) { [{ retry_if: @check, methods: [] }] }
-
-      it 'calls retry_if for all methods' do
-        @check = ->(_, _) { calls.size < 2 }
-        expect { conn.get('/unstable') }.to raise_error(Errno::ETIMEDOUT)
-        expect(times_called).to eq(2)
-      end
-    end
-  end
-
-  describe 'retry_after header support' do
-    let(:callback) { -> { [504, headers, ''] } }
-    let(:elapsed) { Time.now - @started }
-
-    before do
-      @started = Time.now
-      conn.get('/unstable')
-    end
-
-    context 'when retry_after bigger than interval' do
-      let(:headers) { { 'Retry-After' => '0.5' } }
-      let(:options) { [{ max: 1, interval: 0.1, retry_statuses: 504 }] }
-
-      it { expect(elapsed).to be > 0.5 }
-    end
-
-    context 'when retry_after smaller than interval' do
-      let(:headers) { { 'Retry-After' => '0.1' } }
-      let(:options) { [{ max: 1, interval: 0.2, retry_statuses: 504 }] }
-
-      it { expect(elapsed).to be > 0.2 }
-    end
-
-    context 'when retry_after is a timestamp' do
-      let(:headers) { { 'Retry-After' => (Time.now.utc + 2).strftime('%a, %d %b %Y %H:%M:%S GMT') } }
-      let(:options) { [{ max: 1, interval: 0.1, retry_statuses: 504 }] }
-
-      it { expect(elapsed).to be > 1 }
-    end
-
-    context 'when retry_after is bigger than max_interval' do
-      let(:headers) { { 'Retry-After' => (Time.now.utc + 20).strftime('%a, %d %b %Y %H:%M:%S GMT') } }
-      let(:options) { [{ max: 2, interval: 0.1, max_interval: 5, retry_statuses: 504 }] }
-
-      it { expect(times_called).to eq(1) }
-    end
-  end
-end

data/.bundle/ruby/3.0.0/gems/faraday-1.4.1/spec/faraday/request/url_encoded_spec.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Request::UrlEncoded do
-  let(:conn) do
-    Faraday.new do |b|
-      b.request :multipart
-      b.request :url_encoded
-      b.adapter :test do |stub|
-        stub.post('/echo') do |env|
-          posted_as = env[:request_headers]['Content-Type']
-          [200, { 'Content-Type' => posted_as }, env[:body]]
-        end
-      end
-    end
-  end
-
-  it 'does nothing without payload' do
-    response = conn.post('/echo')
-    expect(response.headers['Content-Type']).to be_nil
-    expect(response.body.empty?).to be_truthy
-  end
-
-  it 'ignores custom content type' do
-    response = conn.post('/echo', { some: 'data' }, 'content-type' => 'application/x-foo')
-    expect(response.headers['Content-Type']).to eq('application/x-foo')
-    expect(response.body).to eq(some: 'data')
-  end
-
-  it 'works with no headers' do
-    response = conn.post('/echo', fruit: %w[apples oranges])
-    expect(response.headers['Content-Type']).to eq('application/x-www-form-urlencoded')
-    expect(response.body).to eq('fruit%5B%5D=apples&fruit%5B%5D=oranges')
-  end
-
-  it 'works with with headers' do
-    response = conn.post('/echo', { 'a' => 123 }, 'content-type' => 'application/x-www-form-urlencoded')
-    expect(response.headers['Content-Type']).to eq('application/x-www-form-urlencoded')
-    expect(response.body).to eq('a=123')
-  end
-
-  it 'works with nested params' do
-    response = conn.post('/echo', user: { name: 'Mislav', web: 'mislav.net' })
-    expect(response.headers['Content-Type']).to eq('application/x-www-form-urlencoded')
-    expected = { 'user' => { 'name' => 'Mislav', 'web' => 'mislav.net' } }
-    expect(Faraday::Utils.parse_nested_query(response.body)).to eq(expected)
-  end
-
-  it 'works with non nested params' do
-    response = conn.post('/echo', dimensions: %w[date location]) do |req|
-      req.options.params_encoder = Faraday::FlatParamsEncoder
-    end
-    expect(response.headers['Content-Type']).to eq('application/x-www-form-urlencoded')
-    expected = { 'dimensions' => %w[date location] }
-    expect(Faraday::Utils.parse_query(response.body)).to eq(expected)
-    expect(response.body).to eq('dimensions=date&dimensions=location')
-  end
-
-  it 'works with unicode' do
-    err = capture_warnings do
-      response = conn.post('/echo', str: 'eé cç aã aâ')
-      expect(response.body).to eq('str=e%C3%A9+c%C3%A7+a%C3%A3+a%C3%A2')
-    end
-    expect(err.empty?).to be_truthy
-  end
-
-  it 'works with nested keys' do
-    response = conn.post('/echo', 'a' => { 'b' => { 'c' => ['d'] } })
-    expect(response.body).to eq('a%5Bb%5D%5Bc%5D%5B%5D=d')
-  end
-
-  context 'customising default_space_encoding' do
-    around do |example|
-      Faraday::Utils.default_space_encoding = '%20'
-      example.run
-      Faraday::Utils.default_space_encoding = nil
-    end
-
-    it 'uses the custom character to encode spaces' do
-      response = conn.post('/echo', str: 'apple banana')
-      expect(response.body).to eq('str=apple%20banana')
-    end
-  end
-end

data/.bundle/ruby/3.0.0/gems/faraday-1.4.1/spec/faraday/request_spec.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Request do
-  let(:conn) do
-    Faraday.new(url: 'http://sushi.com/api',
-                headers: { 'Mime-Version' => '1.0' },
-                request: { oauth: { consumer_key: 'anonymous' } })
-  end
-  let(:http_method) { :get }
-  let(:block) { nil }
-
-  subject { conn.build_request(http_method, &block) }
-
-  context 'when nothing particular is configured' do
-    it { expect(subject.http_method).to eq(:get) }
-    it { expect(subject.to_env(conn).ssl.verify).to be_falsey }
-  end
-
-  context 'when HTTP method is post' do
-    let(:http_method) { :post }
-
-    it { expect(subject.http_method).to eq(:post) }
-  end
-
-  describe 'deprecate method for HTTP method' do
-    let(:http_method) { :post }
-    let(:expected_warning) do
-      %r{WARNING: `Faraday::Request#method` is deprecated; use `#http_method` instead. It will be removed in or after version 2.0.\n`Faraday::Request#method` called from .+/spec/faraday/request_spec.rb:\d+.}
-    end
-
-    it { expect(subject.method).to eq(:post) }
-
-    it { expect { subject.method }.to output(expected_warning).to_stderr }
-  end
-
-  context 'when setting the url on setup with a URI' do
-    let(:block) { proc { |req| req.url URI.parse('foo.json?a=1') } }
-
-    it { expect(subject.path).to eq(URI.parse('foo.json')) }
-    it { expect(subject.params).to eq('a' => '1') }
-    it { expect(subject.to_env(conn).url.to_s).to eq('http://sushi.com/api/foo.json?a=1') }
-  end
-
-  context 'when setting the url on setup with a string path and params' do
-    let(:block) { proc { |req| req.url 'foo.json', 'a' => 1 } }
-
-    it { expect(subject.path).to eq('foo.json') }
-    it { expect(subject.params).to eq('a' => 1) }
-    it { expect(subject.to_env(conn).url.to_s).to eq('http://sushi.com/api/foo.json?a=1') }
-  end
-
-  context 'when setting the url on setup with a path including params' do
-    let(:block) { proc { |req| req.url 'foo.json?b=2&a=1#qqq' } }
-
-    it { expect(subject.path).to eq('foo.json') }
-    it { expect(subject.params).to eq('a' => '1', 'b' => '2') }
-    it { expect(subject.to_env(conn).url.to_s).to eq('http://sushi.com/api/foo.json?a=1&b=2') }
-  end
-
-  context 'when setting a header on setup with []= syntax' do
-    let(:block) { proc { |req| req['Server'] = 'Faraday' } }
-    let(:headers) { subject.to_env(conn).request_headers }
-
-    it { expect(subject.headers['Server']).to eq('Faraday') }
-    it { expect(headers['mime-version']).to eq('1.0') }
-    it { expect(headers['server']).to eq('Faraday') }
-  end
-
-  context 'when setting the body on setup' do
-    let(:block) { proc { |req| req.body = 'hi' } }
-
-    it { expect(subject.body).to eq('hi') }
-    it { expect(subject.to_env(conn).body).to eq('hi') }
-  end
-
-  context 'with global request options set' do
-    let(:env_request) { subject.to_env(conn).request }
-
-    before do
-      conn.options.timeout = 3
-      conn.options.open_timeout = 5
-      conn.ssl.verify = false
-      conn.proxy = 'http://proxy.com'
-    end
-
-    it { expect(subject.options.timeout).to eq(3) }
-    it { expect(subject.options.open_timeout).to eq(5) }
-    it { expect(env_request.timeout).to eq(3) }
-    it { expect(env_request.open_timeout).to eq(5) }
-
-    context 'and per-request options set' do
-      let(:block) do
-        proc do |req|
-          req.options.timeout = 10
-          req.options.boundary = 'boo'
-          req.options.oauth[:consumer_secret] = 'xyz'
-          req.options.context = {
-            foo: 'foo',
-            bar: 'bar'
-          }
-        end
-      end
-
-      it { expect(subject.options.timeout).to eq(10) }
-      it { expect(subject.options.open_timeout).to eq(5) }
-      it { expect(env_request.timeout).to eq(10) }
-      it { expect(env_request.open_timeout).to eq(5) }
-      it { expect(env_request.boundary).to eq('boo') }
-      it { expect(env_request.context).to eq(foo: 'foo', bar: 'bar') }
-      it do
-        oauth_expected = { consumer_secret: 'xyz', consumer_key: 'anonymous' }
-        expect(env_request.oauth).to eq(oauth_expected)
-      end
-    end
-  end
-
-  it 'supports marshal serialization' do
-    expect(Marshal.load(Marshal.dump(subject))).to eq(subject)
-  end
-end

data/.bundle/ruby/3.0.0/gems/faraday-1.4.1/spec/faraday/response/logger_spec.rb

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-require 'stringio'
-require 'logger'
-
-RSpec.describe Faraday::Response::Logger do
-  let(:string_io) { StringIO.new }
-  let(:logger) { Logger.new(string_io) }
-  let(:logger_options) { {} }
-  let(:conn) do
-    rubbles = ['Barney', 'Betty', 'Bam Bam']
-
-    Faraday.new do |b|
-      b.response :logger, logger, logger_options do |logger|
-        logger.filter(/(soylent green is) (.+)/, '\1 tasty')
-        logger.filter(/(api_key:).*"(.+)."/, '\1[API_KEY]')
-        logger.filter(/(password)=(.+)/, '\1=[HIDDEN]')
-      end
-      b.adapter :test do |stubs|
-        stubs.get('/hello') { [200, { 'Content-Type' => 'text/html' }, 'hello'] }
-        stubs.post('/ohai') { [200, { 'Content-Type' => 'text/html' }, 'fred'] }
-        stubs.post('/ohyes') { [200, { 'Content-Type' => 'text/html' }, 'pebbles'] }
-        stubs.get('/rubbles') { [200, { 'Content-Type' => 'application/json' }, rubbles] }
-        stubs.get('/filtered_body') { [200, { 'Content-Type' => 'text/html' }, 'soylent green is people'] }
-        stubs.get('/filtered_headers') { [200, { 'Content-Type' => 'text/html' }, 'headers response'] }
-        stubs.get('/filtered_params') { [200, { 'Content-Type' => 'text/html' }, 'params response'] }
-        stubs.get('/filtered_url') { [200, { 'Content-Type' => 'text/html' }, 'url response'] }
-      end
-    end
-  end
-
-  before do
-    logger.level = Logger::DEBUG
-  end
-
-  it 'still returns output' do
-    resp = conn.get '/hello', nil, accept: 'text/html'
-    expect(resp.body).to eq('hello')
-  end
-
-  context 'without configuration' do
-    let(:conn) do
-      Faraday.new do |b|
-        b.response :logger
-        b.adapter :test do |stubs|
-          stubs.get('/hello') { [200, { 'Content-Type' => 'text/html' }, 'hello'] }
-        end
-      end
-    end
-
-    it 'defaults to stdout' do
-      expect(Logger).to receive(:new).with($stdout).and_return(Logger.new(nil))
-      conn.get('/hello')
-    end
-  end
-
-  context 'with default formatter' do
-    let(:formatter) { instance_double(Faraday::Logging::Formatter, request: true, response: true, filter: []) }
-
-    before { allow(Faraday::Logging::Formatter).to receive(:new).and_return(formatter) }
-
-    it 'delegates logging to the formatter' do
-      expect(formatter).to receive(:request).with(an_instance_of(Faraday::Env))
-      expect(formatter).to receive(:response).with(an_instance_of(Faraday::Env))
-      conn.get '/hello'
-    end
-  end
-
-  context 'with custom formatter' do
-    let(:formatter_class) do
-      Class.new(Faraday::Logging::Formatter) do
-        def request(_env)
-          info 'Custom log formatter request'
-        end
-
-        def response(_env)
-          info 'Custom log formatter response'
-        end
-      end
-    end
-
-    let(:logger_options) { { formatter: formatter_class } }
-
-    it 'logs with custom formatter' do
-      conn.get '/hello'
-
-      expect(string_io.string).to match('Custom log formatter request')
-      expect(string_io.string).to match('Custom log formatter response')
-    end
-  end
-
-  it 'logs method and url' do
-    conn.get '/hello', nil, accept: 'text/html'
-    expect(string_io.string).to match('GET http:/hello')
-  end
-
-  it 'logs request headers by default' do
-    conn.get '/hello', nil, accept: 'text/html'
-    expect(string_io.string).to match(%(Accept: "text/html))
-  end
-
-  it 'logs response headers by default' do
-    conn.get '/hello', nil, accept: 'text/html'
-    expect(string_io.string).to match(%(Content-Type: "text/html))
-  end
-
-  it 'does not log request body by default' do
-    conn.post '/ohai', 'name=Unagi', accept: 'text/html'
-    expect(string_io.string).not_to match(%(name=Unagi))
-  end
-
-  it 'does not log response body by default' do
-    conn.post '/ohai', 'name=Toro', accept: 'text/html'
-    expect(string_io.string).not_to match(%(fred))
-  end
-
-  it 'logs filter headers' do
-    conn.headers = { 'api_key' => 'ABC123' }
-    conn.get '/filtered_headers', nil, accept: 'text/html'
-    expect(string_io.string).to match(%(api_key:))
-    expect(string_io.string).to match(%([API_KEY]))
-    expect(string_io.string).not_to match(%(ABC123))
-  end
-
-  it 'logs filter url' do
-    conn.get '/filtered_url?password=hunter2', nil, accept: 'text/html'
-    expect(string_io.string).to match(%([HIDDEN]))
-    expect(string_io.string).not_to match(%(hunter2))
-  end
-
-  context 'when not logging request headers' do
-    let(:logger_options) { { headers: { request: false } } }
-
-    it 'does not log request headers if option is false' do
-      conn.get '/hello', nil, accept: 'text/html'
-      expect(string_io.string).not_to match(%(Accept: "text/html))
-    end
-  end
-
-  context 'when not logging response headers' do
-    let(:logger_options) { { headers: { response: false } } }
-
-    it 'does not log response headers if option is false' do
-      conn.get '/hello', nil, accept: 'text/html'
-      expect(string_io.string).not_to match(%(Content-Type: "text/html))
-    end
-  end
-
-  context 'when logging request body' do
-    let(:logger_options) { { bodies: { request: true } } }
-
-    it 'log only request body' do
-      conn.post '/ohyes', 'name=Tamago', accept: 'text/html'
-      expect(string_io.string).to match(%(name=Tamago))
-      expect(string_io.string).not_to match(%(pebbles))
-    end
-  end
-
-  context 'when logging response body' do
-    let(:logger_options) { { bodies: { response: true } } }
-
-    it 'log only response body' do
-      conn.post '/ohyes', 'name=Hamachi', accept: 'text/html'
-      expect(string_io.string).to match(%(pebbles))
-      expect(string_io.string).not_to match(%(name=Hamachi))
-    end
-  end
-
-  context 'when logging request and response bodies' do
-    let(:logger_options) { { bodies: true } }
-
-    it 'log request and response body' do
-      conn.post '/ohyes', 'name=Ebi', accept: 'text/html'
-      expect(string_io.string).to match(%(name=Ebi))
-      expect(string_io.string).to match(%(pebbles))
-    end
-
-    it 'log response body object' do
-      conn.get '/rubbles', nil, accept: 'text/html'
-      expect(string_io.string).to match(%([\"Barney\", \"Betty\", \"Bam Bam\"]\n))
-    end
-
-    it 'logs filter body' do
-      conn.get '/filtered_body', nil, accept: 'text/html'
-      expect(string_io.string).to match(%(soylent green is))
-      expect(string_io.string).to match(%(tasty))
-      expect(string_io.string).not_to match(%(people))
-    end
-  end
-
-  context 'when using log_level' do
-    let(:logger_options) { { bodies: true, log_level: :debug } }
-
-    it 'logs request/request body on the specified level (debug)' do
-      logger.level = Logger::DEBUG
-      conn.post '/ohyes', 'name=Ebi', accept: 'text/html'
-      expect(string_io.string).to match(%(name=Ebi))
-      expect(string_io.string).to match(%(pebbles))
-    end
-
-    it 'logs headers on the debug level' do
-      logger.level = Logger::DEBUG
-      conn.get '/hello', nil, accept: 'text/html'
-      expect(string_io.string).to match(%(Content-Type: "text/html))
-    end
-
-    it 'does not log request/response body on the info level' do
-      logger.level = Logger::INFO
-      conn.post '/ohyes', 'name=Ebi', accept: 'text/html'
-      expect(string_io.string).not_to match(%(name=Ebi))
-      expect(string_io.string).not_to match(%(pebbles))
-    end
-
-    it 'does not log headers on the info level' do
-      logger.level = Logger::INFO
-      conn.get '/hello', nil, accept: 'text/html'
-      expect(string_io.string).not_to match(%(Content-Type: "text/html))
-    end
-  end
-end