logstash-output-scalyr 0.1.5 → 0.1.10.beta

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/spec/faraday/options/request_options_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::RequestOptions do
-  subject(:options) { Faraday::RequestOptions.new }
-
-  it 'allows to set the request proxy' do
-    expect(options.proxy).to be_nil
-
-    expect { options[:proxy] = { booya: 1 } }.to raise_error(NoMethodError)
-
-    options[:proxy] = { user: 'user' }
-    expect(options.proxy).to be_a_kind_of(Faraday::ProxyOptions)
-    expect(options.proxy.user).to eq('user')
-
-    options.proxy = nil
-    expect(options.proxy).to be_nil
-    expect(options.inspect).to eq('#<Faraday::RequestOptions (empty)>')
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/spec/faraday/params_encoders/flat_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack/utils'
-
-RSpec.describe Faraday::FlatParamsEncoder do
-  it_behaves_like 'a params encoder'
-
-  it 'decodes arrays' do
-    query = 'a=one&a=two&a=three'
-    expected = { 'a' => %w[one two three] }
-    expect(subject.decode(query)).to eq(expected)
-  end
-
-  it 'decodes boolean values' do
-    query = 'a=true&b=false'
-    expected = { 'a' => 'true', 'b' => 'false' }
-    expect(subject.decode(query)).to eq(expected)
-  end
-
-  it 'encodes boolean values' do
-    params = { a: true, b: false }
-    expect(subject.encode(params)).to eq('a=true&b=false')
-  end
-
-  it 'encodes boolean values in array' do
-    params = { a: [true, false] }
-    expect(subject.encode(params)).to eq('a=true&a=false')
-  end
-
-  it 'encodes empty array in hash' do
-    params = { a: [] }
-    expect(subject.encode(params)).to eq('a=')
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/spec/faraday/params_encoders/nested_spec.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack/utils'
-
-RSpec.describe Faraday::NestedParamsEncoder do
-  it_behaves_like 'a params encoder'
-
-  it 'decodes arrays' do
-    query    = 'a[1]=one&a[2]=two&a[3]=three'
-    expected = { 'a' => %w[one two three] }
-    expect(subject.decode(query)).to eq(expected)
-  end
-
-  it 'decodes hashes' do
-    query    = 'a[b1]=one&a[b2]=two&a[b][c]=foo'
-    expected = { 'a' => { 'b1' => 'one', 'b2' => 'two', 'b' => { 'c' => 'foo' } } }
-    expect(subject.decode(query)).to eq(expected)
-  end
-
-  it 'decodes nested arrays rack compat' do
-    query    = 'a[][one]=1&a[][two]=2&a[][one]=3&a[][two]=4'
-    expected = Rack::Utils.parse_nested_query(query)
-    expect(subject.decode(query)).to eq(expected)
-  end
-
-  it 'decodes nested array mixed types' do
-    query    = 'a[][one]=1&a[]=2&a[]=&a[]'
-    expected = Rack::Utils.parse_nested_query(query)
-    expect(subject.decode(query)).to eq(expected)
-  end
-
-  it 'decodes nested ignores invalid array' do
-    query    = '[][a]=1&b=2'
-    expected = { 'a' => '1', 'b' => '2' }
-    expect(subject.decode(query)).to eq(expected)
-  end
-
-  it 'decodes nested ignores repeated array notation' do
-    query    = 'a[][][]=1'
-    expected = { 'a' => ['1'] }
-    expect(subject.decode(query)).to eq(expected)
-  end
-
-  it 'decodes nested ignores malformed keys' do
-    query    = '=1&[]=2'
-    expected = {}
-    expect(subject.decode(query)).to eq(expected)
-  end
-
-  it 'decodes nested subkeys dont have to be in brackets' do
-    query    = 'a[b]c[d]e=1'
-    expected = { 'a' => { 'b' => { 'c' => { 'd' => { 'e' => '1' } } } } }
-    expect(subject.decode(query)).to eq(expected)
-  end
-
-  it 'decodes nested final value overrides any type' do
-    query    = 'a[b][c]=1&a[b]=2'
-    expected = { 'a' => { 'b' => '2' } }
-    expect(subject.decode(query)).to eq(expected)
-  end
-
-  it 'encodes rack compat' do
-    params   = { a: [{ one: '1', two: '2' }, '3', ''] }
-    result   = Faraday::Utils.unescape(Faraday::NestedParamsEncoder.encode(params)).split('&')
-    expected = Rack::Utils.build_nested_query(params).split('&')
-    expect(result).to match_array(expected)
-  end
-
-  it 'encodes empty string array value' do
-    expected = 'baz=&foo%5Bbar%5D='
-    result = Faraday::NestedParamsEncoder.encode(foo: { bar: '' }, baz: '')
-    expect(result).to eq(expected)
-  end
-
-  it 'encodes nil array value' do
-    expected = 'baz&foo%5Bbar%5D'
-    result = Faraday::NestedParamsEncoder.encode(foo: { bar: nil }, baz: nil)
-    expect(result).to eq(expected)
-  end
-
-  it 'encodes empty array value' do
-    expected = 'baz%5B%5D&foo%5Bbar%5D%5B%5D'
-    result = Faraday::NestedParamsEncoder.encode(foo: { bar: [] }, baz: [])
-    expect(result).to eq(expected)
-  end
-
-  it 'encodes boolean values' do
-    params = { a: true, b: false }
-    expect(subject.encode(params)).to eq('a=true&b=false')
-  end
-
-  it 'encodes boolean values in array' do
-    params = { a: [true, false] }
-    expect(subject.encode(params)).to eq('a%5B%5D=true&a%5B%5D=false')
-  end
-
-  shared_examples 'a wrong decoding' do
-    it do
-      expect { subject.decode(query) }.to raise_error(TypeError) do |e|
-        expect(e.message).to eq(error_message)
-      end
-    end
-  end
-
-  context 'when expecting hash but getting string' do
-    let(:query) { 'a=1&a[b]=2' }
-    let(:error_message) { "expected Hash (got String) for param `a'" }
-    it_behaves_like 'a wrong decoding'
-  end
-
-  context 'when expecting hash but getting array' do
-    let(:query) { 'a[]=1&a[b]=2' }
-    let(:error_message) { "expected Hash (got Array) for param `a'" }
-    it_behaves_like 'a wrong decoding'
-  end
-
-  context 'when expecting nested hash but getting non nested' do
-    let(:query) { 'a[b]=1&a[b][c]=2' }
-    let(:error_message) { "expected Hash (got String) for param `b'" }
-    it_behaves_like 'a wrong decoding'
-  end
-
-  context 'when expecting array but getting hash' do
-    let(:query) { 'a[b]=1&a[]=2' }
-    let(:error_message) { "expected Array (got Hash) for param `a'" }
-    it_behaves_like 'a wrong decoding'
-  end
-
-  context 'when expecting array but getting string' do
-    let(:query) { 'a=1&a[]=2' }
-    let(:error_message) { "expected Array (got String) for param `a'" }
-    it_behaves_like 'a wrong decoding'
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/spec/faraday/rack_builder_spec.rb

@@ -1,196 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::RackBuilder do
-  # mock handler classes
-  (Handler = Struct.new(:app)).class_eval do
-    def call(env)
-      env[:request_headers]['X-Middleware'] ||= ''
-      env[:request_headers]['X-Middleware'] += ":#{self.class.name.split('::').last}"
-      app.call(env)
-    end
-  end
-
-  class Apple < Handler
-  end
-  class Orange < Handler
-  end
-  class Banana < Handler
-  end
-
-  class Broken < Faraday::Middleware
-    dependency 'zomg/i_dont/exist'
-  end
-
-  subject { conn.builder }
-
-  context 'with default stack' do
-    let(:conn) { Faraday::Connection.new }
-
-    it { expect(subject[0]).to eq(Faraday::Request.lookup_middleware(:url_encoded)) }
-    it { expect(subject.adapter).to eq(Faraday::Adapter.lookup_middleware(Faraday.default_adapter)) }
-  end
-
-  context 'with custom empty block' do
-    let(:conn) { Faraday::Connection.new {} }
-
-    it { expect(subject[0]).to be_nil }
-    it { expect(subject.adapter).to eq(Faraday::Adapter.lookup_middleware(Faraday.default_adapter)) }
-  end
-
-  context 'with custom adapter only' do
-    let(:conn) do
-      Faraday::Connection.new do |builder|
-        builder.adapter :test do |stub|
-          stub.get('/') { |_| [200, {}, ''] }
-        end
-      end
-    end
-
-    it { expect(subject[0]).to be_nil }
-    it { expect(subject.adapter).to eq(Faraday::Adapter.lookup_middleware(:test)) }
-  end
-
-  context 'with custom handler and adapter' do
-    let(:conn) do
-      Faraday::Connection.new do |builder|
-        builder.use Apple
-        builder.adapter :test do |stub|
-          stub.get('/') { |_| [200, {}, ''] }
-        end
-      end
-    end
-
-    it 'locks the stack after making a request' do
-      expect(subject.locked?).to be_falsey
-      conn.get('/')
-      expect(subject.locked?).to be_truthy
-      expect { subject.use(Orange) }.to raise_error(Faraday::RackBuilder::StackLocked)
-    end
-
-    it 'dup stack is unlocked' do
-      expect(subject.locked?).to be_falsey
-      subject.lock!
-      expect(subject.locked?).to be_truthy
-      dup = subject.dup
-      expect(dup).to eq(subject)
-      expect(dup.locked?).to be_falsey
-    end
-
-    it 'allows to compare handlers' do
-      expect(subject.handlers.first).to eq(Faraday::RackBuilder::Handler.new(Apple))
-    end
-  end
-
-  context 'when having a single handler' do
-    let(:conn) { Faraday::Connection.new {} }
-
-    before { subject.use(Apple) }
-
-    it { expect(subject.handlers).to eq([Apple]) }
-
-    it 'allows rebuilding' do
-      subject.build do |builder|
-        builder.use(Orange)
-      end
-      expect(subject.handlers).to eq([Orange])
-    end
-
-    it 'allows use' do
-      subject.use(Orange)
-      expect(subject.handlers).to eq([Apple, Orange])
-    end
-
-    it 'allows insert_before' do
-      subject.insert_before(Apple, Orange)
-      expect(subject.handlers).to eq([Orange, Apple])
-    end
-
-    it 'allows insert_after' do
-      subject.insert_after(Apple, Orange)
-      expect(subject.handlers).to eq([Apple, Orange])
-    end
-
-    it 'raises an error trying to use an unregistered symbol' do
-      expect { subject.use(:apple) }.to raise_error(Faraday::Error) do |err|
-        expect(err.message).to eq(':apple is not registered on Faraday::Middleware')
-      end
-    end
-  end
-
-  context 'with custom registered middleware' do
-    let(:conn) { Faraday::Connection.new {} }
-
-    after { Faraday::Middleware.unregister_middleware(:apple) }
-
-    it 'allows to register with constant' do
-      Faraday::Middleware.register_middleware(apple: Apple)
-      subject.use(:apple)
-      expect(subject.handlers).to eq([Apple])
-    end
-
-    it 'allows to register with symbol' do
-      Faraday::Middleware.register_middleware(apple: :Apple)
-      subject.use(:apple)
-      expect(subject.handlers).to eq([Apple])
-    end
-
-    it 'allows to register with string' do
-      Faraday::Middleware.register_middleware(apple: 'Apple')
-      subject.use(:apple)
-      expect(subject.handlers).to eq([Apple])
-    end
-
-    it 'allows to register with Proc' do
-      Faraday::Middleware.register_middleware(apple: -> { Apple })
-      subject.use(:apple)
-      expect(subject.handlers).to eq([Apple])
-    end
-  end
-
-  context 'when having two handlers' do
-    let(:conn) { Faraday::Connection.new {} }
-
-    before do
-      subject.use(Apple)
-      subject.use(Orange)
-    end
-
-    it 'allows insert_before' do
-      subject.insert_before(Orange, Banana)
-      expect(subject.handlers).to eq([Apple, Banana, Orange])
-    end
-
-    it 'allows insert_after' do
-      subject.insert_after(Apple, Banana)
-      expect(subject.handlers).to eq([Apple, Banana, Orange])
-    end
-
-    it 'allows to swap handlers' do
-      subject.swap(Apple, Banana)
-      expect(subject.handlers).to eq([Banana, Orange])
-    end
-
-    it 'allows to delete a handler' do
-      subject.delete(Apple)
-      expect(subject.handlers).to eq([Orange])
-    end
-  end
-
-  context 'when having a handler with broken dependency' do
-    let(:conn) do
-      Faraday::Connection.new do |builder|
-        builder.adapter :test do |stub|
-          stub.get('/') { |_| [200, {}, ''] }
-        end
-      end
-    end
-
-    before { subject.use(Broken) }
-
-    it 'raises an error while making a request' do
-      expect { conn.get('/') }.to raise_error(RuntimeError) do |err|
-        expect(err.message).to match(%r{missing dependency for Broken: .+ -- zomg/i_dont/exist})
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/spec/faraday/request/authorization_spec.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Request::Authorization do
-  let(:conn) do
-    Faraday.new do |b|
-      b.request auth_type, *auth_config
-      b.adapter :test do |stub|
-        stub.get('/auth-echo') do |env|
-          [200, {}, env[:request_headers]['Authorization']]
-        end
-      end
-    end
-  end
-
-  shared_examples 'does not interfere with existing authentication' do
-    context 'and request already has an authentication header' do
-      let(:response) { conn.get('/auth-echo', nil, authorization: 'Token token="bar"') }
-
-      it 'does not interfere with existing authorization' do
-        expect(response.body).to eq('Token token="bar"')
-      end
-    end
-  end
-
-  let(:response) { conn.get('/auth-echo') }
-
-  describe 'basic_auth' do
-    let(:auth_type) { :basic_auth }
-
-    context 'when passed correct params' do
-      let(:auth_config) { %w[aladdin opensesame] }
-
-      it { expect(response.body).to eq('Basic YWxhZGRpbjpvcGVuc2VzYW1l') }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-
-    context 'when passed very long values' do
-      let(:auth_config) { ['A' * 255, ''] }
-
-      it { expect(response.body).to eq("Basic #{'QUFB' * 85}Og==") }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-  end
-
-  describe 'token_auth' do
-    let(:auth_type) { :token_auth }
-
-    context 'when passed correct params' do
-      let(:auth_config) { 'quux' }
-
-      it { expect(response.body).to eq('Token token="quux"') }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-
-    context 'when other values are provided' do
-      let(:auth_config) { ['baz', foo: 42] }
-
-      it { expect(response.body).to match(/^Token /) }
-      it { expect(response.body).to match(/token="baz"/) }
-      it { expect(response.body).to match(/foo="42"/) }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-  end
-
-  describe 'authorization' do
-    let(:auth_type) { :authorization }
-
-    context 'when passed two strings' do
-      let(:auth_config) { ['custom', 'abc def'] }
-
-      it { expect(response.body).to eq('custom abc def') }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-
-    context 'when passed a string and a hash' do
-      let(:auth_config) { ['baz', foo: 42] }
-
-      it { expect(response.body).to eq('baz foo="42"') }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-  end
-end