excon 0.62.0 → 0.85.0

data/tests/middlewares/instrumentation_tests.rb

@@ -1,315 +0,0 @@
-require 'active_support/notifications'
-require 'securerandom'
-
-class SimpleInstrumentor
-  class << self
-    attr_accessor :events, :blocks
-
-    def instrument(name, params = {}, &block)
-      @events << name
-      @blocks << name if block_given?
-
-      yield if block_given?
-    end
-
-    def reset!
-      @events = []
-      @blocks = []
-    end
-  end
-end
-
-Shindo.tests('Excon instrumentation') do
-
-  after do
-    ActiveSupport::Notifications.unsubscribe("excon")
-    ActiveSupport::Notifications.unsubscribe("excon.request")
-    ActiveSupport::Notifications.unsubscribe("excon.response")
-    ActiveSupport::Notifications.unsubscribe("excon.retry")
-    ActiveSupport::Notifications.unsubscribe("excon.error")
-    ActiveSupport::Notifications.unsubscribe("gug")
-    Delorean.back_to_the_present
-    Excon.stubs.clear
-  end
-
-  before do
-    SimpleInstrumentor.reset!
-  end
-
-  def subscribe(match)
-    @events = []
-    ActiveSupport::Notifications.subscribe(match) do |*args|
-      @events << ActiveSupport::Notifications::Event.new(*args)
-    end
-  end
-
-  def make_request(idempotent = false, params = {})
-    connection = Excon.new(
-      'http://127.0.0.1:9292',
-      :instrumentor => ActiveSupport::Notifications,
-      :mock         => true
-    )
-    if idempotent
-      params[:idempotent] = :true
-    end
-    connection.get(params)
-  end
-
-  REQUEST_DELAY_SECONDS = 30
-  def stub_success
-    Excon.stub({:method => :get}) { |params|
-      Delorean.jump REQUEST_DELAY_SECONDS
-      {:body => params[:body], :headers => params[:headers], :status => 200}
-    }
-  end
-
-  def stub_retries
-    run_count = 0
-    Excon.stub({:method => :get}) { |params|
-      run_count += 1
-      if run_count <= 3 # First 3 calls fail.
-        raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
-      else
-        {:body => params[:body], :headers => params[:headers], :status => 200}
-      end
-    }
-  end
-
-  def stub_failure
-    Excon.stub({:method => :get}) { |params|
-      raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
-    }
-  end
-
-  tests('basic notification').returns(['excon.request', 'excon.response']) do
-    subscribe(/excon/)
-    stub_success
-    make_request
-    @events.map(&:name)
-  end
-
-  tests('captures scheme, host, port, and path').returns([:host, :path, :port, :scheme]) do
-    subscribe(/excon/)
-    stub_success
-    make_request
-    [:host, :path, :port, :scheme].select {|k| @events.first.payload.has_key? k}
-  end
-
-  tests('params in request overwrite those in constructor').returns('/cheezburger') do
-    subscribe(/excon/)
-    stub_success
-    make_request(false, :path => '/cheezburger')
-    @events.first.payload[:path]
-  end
-
-  tests('notify on retry').returns(3) do
-    subscribe(/excon/)
-    stub_retries
-    make_request(true)
-    @events.count{|e| e.name =~ /retry/}
-  end
-
-  tests('notify on error').returns(true) do
-    subscribe(/excon/)
-    stub_failure
-    raises(Excon::Errors::SocketError) do
-      make_request
-    end
-
-    @events.any?{|e| e.name =~ /error/}
-  end
-
-  tests('filtering').returns(['excon.request', 'excon.error']) do
-    subscribe(/excon.request/)
-    subscribe(/excon.error/)
-    stub_failure
-    raises(Excon::Errors::SocketError) do
-      make_request(true)
-    end
-
-    @events.map(&:name)
-  end
-
-  tests('more filtering').returns(['excon.retry', 'excon.retry', 'excon.retry']) do
-    subscribe(/excon.retry/)
-    stub_failure
-    raises(Excon::Errors::SocketError) do
-      make_request(true)
-    end
-
-    @events.map(&:name)
-  end
-
-  tests('indicates duration').returns(true) do
-    subscribe(/excon/)
-    stub_success
-    make_request
-    (@events.first.duration/1000 - REQUEST_DELAY_SECONDS).abs < 1
-  end
-
-  tests('standard instrumentor') do
-
-    tests('success').returns(
-      ['excon.request', 'excon.retry', 'excon.retry', 'excon.retry', 'excon.error']) do
-
-      begin
-        original_stderr = $stderr
-        $stderr = captured_stderr = StringIO.new
-        stub_failure
-        connection = Excon.new(
-          'http://127.0.0.1:9292',
-          :instrumentor => Excon::StandardInstrumentor,
-          :mock         => true
-        )
-        raises(Excon::Errors::SocketError) do
-          connection.get(:idempotent => true)
-        end
-
-        captured_stderr.string.split("\n").reject {|line| line =~ %r{^  }}.map {|event| event.split(' ').first}
-      ensure
-        $stderr = original_stderr
-      end
-    end
-
-    tests('authorization header REDACT') do
-
-      @auth_header = 'Basic dXNlcjpwYXNz'
-
-      begin
-        original_stderr = $stderr
-        $stderr = @captured_stderr = StringIO.new
-        stub_failure
-        raises(Excon::Errors::SocketError) do
-          @connection = Excon.new(
-            'http://user:pass@127.0.0.1:9292',
-            :headers      => {
-              'Authorization' => @auth_header
-            },
-            :instrumentor => Excon::StandardInstrumentor,
-            :mock         => true
-          )
-          @connection.get(:idempotent => true)
-        end
-      ensure
-        $stderr = original_stderr
-      end
-
-      test('does not appear in response') do
-        !@captured_stderr.string.include?(@auth_header)
-      end
-
-      test('does not mutate Authorization value') do
-        @connection.data[:headers]['Authorization'] == @auth_header
-      end
-
-    end
-
-    tests('password REDACT') do
-
-      begin
-        original_stderr = $stderr
-        $stderr = @captured_stderr = StringIO.new
-        stub_failure
-        raises(Excon::Errors::SocketError) do
-          @connection = Excon.new(
-            'http://user:pass@127.0.0.1:9292',
-            :instrumentor => Excon::StandardInstrumentor,
-            :mock         => true
-            )
-          @connection.get(:idempotent => true)
-        end
-      ensure
-        $stderr = original_stderr
-      end
-
-      @password_param = '"pass"'
-
-      test('does not appear in response') do
-        !@captured_stderr.string.include?(@password_param)
-      end
-
-      test('does not mutate password value') do
-        @connection.data[:password] == "pass"
-      end
-
-    end
-
-  end
-
-  tests('use our own instrumentor').returns(
-      ['excon.request', 'excon.retry', 'excon.retry', 'excon.retry', 'excon.error']) do
-    stub_failure
-    connection = Excon.new(
-      'http://127.0.0.1:9292',
-      :instrumentor => SimpleInstrumentor,
-      :mock         => true
-    )
-    raises(Excon::Errors::SocketError) do
-      connection.get(:idempotent => true)
-    end
-
-    SimpleInstrumentor.events
-  end
-
-  tests('always passes the block').returns(
-      ['excon.request', 'excon.response']) do
-    stub_success
-    connection = Excon.new(
-      'http://127.0.0.1:9292',
-      :instrumentor => SimpleInstrumentor,
-      :mock         => true
-    )
-    connection.get(:idempotent => true)
-
-    SimpleInstrumentor.blocks
-  end
-
-  tests('does not generate events when not provided').returns(0) do
-    subscribe(/excon/)
-    stub_success
-    connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-    connection.get(:idempotent => true)
-    @events.count
-  end
-
-  tests('allows setting the prefix').returns(
-      ['gug.request', 'gug.retry', 'gug.retry','gug.retry', 'gug.error']) do
-    subscribe(/gug/)
-    stub_failure
-    connection = Excon.new(
-      'http://127.0.0.1:9292',
-      :instrumentor       => ActiveSupport::Notifications,
-      :instrumentor_name  => 'gug',
-      :mock               => true
-    )
-    raises(Excon::Errors::SocketError) do
-      connection.get(:idempotent => true)
-    end
-    @events.map(&:name)
-  end
-
-  tests('allows setting the prefix when not idempotent', 'foo').returns(
-    ['gug.request', 'gug.error']) do
-    subscribe(/gug/)
-    stub_failure
-    connection = Excon.new(
-      'http://127.0.0.1:9292',
-      :instrumentor       => ActiveSupport::Notifications,
-      :instrumentor_name  => 'gug',
-      :mock               => true
-    )
-    raises(Excon::Errors::SocketError) do
-      connection.get()
-    end
-    @events.map(&:name)
-  end
-
-  with_rackup('basic.ru') do
-    tests('works unmocked').returns(['excon.request', 'excon.response']) do
-      subscribe(/excon/)
-      make_request(false, :mock => false)
-      @events.map(&:name)
-    end
-  end
-end
-

data/tests/middlewares/mock_tests.rb

@@ -1,304 +0,0 @@
-Shindo.tests('Excon stubs') do
-  env_init
-
-  tests("missing stub").raises(Excon::Errors::StubNotFound) do
-    connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-    connection.request(:method => :get, :path => '/content-length/100')
-  end
-
-  tests("stub({})").raises(ArgumentError) do
-    Excon.stub({})
-  end
-
-  tests("stub({}, {}) {}").raises(ArgumentError) do
-    Excon.stub({}, {}) {}
-  end
-
-  tests("stub({:method => :get}, {:body => 'body', :status => 200})") do
-    connection = nil
-    response = nil
-
-    tests('response.body').returns('body') do
-      Excon.stub({:method => :get}, {:body => 'body', :status => 200})
-
-      connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-      response = connection.request(:method => :get, :path => '/content-length/100')
-
-      response.body
-    end
-
-    tests('response.headers').returns({}) do
-      response.headers
-    end
-
-    tests('response.status').returns(200) do
-      response.status
-    end
-
-    tests('response_block yields body').returns('body') do
-      body = ''
-      response_block = lambda do |chunk, remaining_bytes, total_bytes|
-        body << chunk
-      end
-      connection.request(:method => :get, :path => '/content-length/100', :response_block => response_block)
-      body
-    end
-
-    tests('response.body empty with response_block').returns('') do
-      response_block = lambda { |_, _, _| }
-      connection.request(:method => :get, :path => '/content-length/100', :response_block => response_block).body
-    end
-
-    Excon.stubs.clear
-
-  end
-
-  tests("stub({:path => %r{/tests/(\S+)}}, {:body => $1, :status => 200})") do
-    connection = nil
-    response = nil
-
-    tests('response.body').returns('test') do
-      Excon.stub({:path => %r{/tests/(\S+)}}) do |params|
-        {
-          :body => params[:captures][:path].first,
-          :status => 200
-        }
-      end
-
-      connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-      response = connection.request(:method => :get, :path => '/tests/test')
-
-      response.body
-    end
-
-    tests('response.headers').returns({}) do
-      response.headers
-    end
-
-    tests('response.status').returns(200) do
-      response.status
-    end
-
-    Excon.stubs.clear
-
-  end
-
-  tests("stub({:body => 'body', :method => :get}) {|params| {:body => params[:body], :headers => params[:headers], :status => 200}}") do
-    connection = nil
-    response = nil
-
-    tests('response.body').returns('body') do
-      Excon.stub({:body => 'body', :method => :get}) {|params| {:body => params[:body], :headers => params[:headers], :status => 200}}
-
-      connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-      response = connection.request(:body => 'body', :method => :get, :path => '/content-length/100')
-
-      response.body
-    end
-
-    tests('response.headers').returns({'Host' => '127.0.0.1:9292', 'User-Agent' => "excon/#{Excon::VERSION}"}) do
-      response.headers
-    end
-
-    tests('response.status').returns(200) do
-      response.status
-    end
-
-    tests('response_block yields body').returns('body') do
-      body = ''
-      response_block = lambda do |chunk, remaining_bytes, total_bytes|
-        body << chunk
-      end
-      connection.request(:body => 'body', :method => :get, :path => '/content-length/100', :response_block => response_block)
-      body
-    end
-
-    tests('response.body empty with response_block').returns('') do
-      response_block = lambda { |_, _, _| }
-      connection.request(:body => 'body', :method => :get, :path => '/content-length/100', :response_block => response_block).body
-    end
-
-    Excon.stubs.clear
-
-  end
-
-  tests("stub({:body => File.open(...), :method => :get}, { :status => 200 })") do
-
-    tests('response.status').returns(200) do
-      file_path = File.join(File.dirname(__FILE__), '..', 'data', 'xs')
-
-      Excon.stub(
-        { :body => File.read(file_path), :method => :get },
-        { :status => 200 }
-      )
-
-      connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-      response = connection.request(:body => File.open(file_path), :method => :get, :path => '/')
-
-      response.status
-    end
-
-    Excon.stubs.clear
-
-  end
-
-  tests("invalid stub response").raises(Excon::Errors::InvalidStub) do
-    Excon.stub({:body => 42, :method => :get}, {:status => 200})
-    connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-    connection.request(:body => 42, :method => :get, :path => '/').status
-  end
-
-  tests("mismatched stub").raises(Excon::Errors::StubNotFound) do
-    Excon.stub({:method => :post}, {:body => 'body'})
-    Excon.get('http://127.0.0.1:9292/', :mock => true)
-  end
-
-  with_server('good') do
-    tests('allow mismatched stub').returns(200) do
-      Excon.stub({:path => '/echo/request_count'}, {:body => 'body'})
-      Excon.get(
-        'http://127.0.0.1:9292/echo/request',
-        :mock => true,
-        :allow_unstubbed_requests => true
-      ).status
-    end
-  end
-
-  Excon.stubs.clear
-
-  tests("stub({}, {:body => 'x' * (Excon::DEFAULT_CHUNK_SIZE + 1)})") do
-
-    test("response_block yields body") do
-      connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-      Excon.stub({}, {:body => 'x' * (Excon::DEFAULT_CHUNK_SIZE + 1)})
-
-      chunks = []
-      response_block = lambda do |chunk, remaining_bytes, total_bytes|
-        chunks << chunk
-      end
-      connection.request(:method => :get, :path => '/content-length/100', :response_block => response_block)
-      chunks == ['x' * Excon::DEFAULT_CHUNK_SIZE, 'x']
-    end
-
-    tests("response.body empty with response_block").returns('') do
-      connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-      Excon.stub({}, {:body => 'x' * (Excon::DEFAULT_CHUNK_SIZE + 1)})
-      response_block = lambda { |_, _, _| }
-      connection.request(:method => :get, :path => '/content-length/100', :response_block => response_block).body
-    end
-
-  end
-
-  Excon.stubs.clear
-
-  tests("stub({:url => 'https://user:pass@foo.bar.com:9999/baz?quux=true'}, {:status => 200})") do
-    test("get(:expects => 200)") do
-      Excon.stub({:url => 'https://user:pass@foo.bar.com:9999/baz?quux=true'}, {:status => 200})
-      Excon.new("https://user:pass@foo.bar.com:9999/baz?quux=true", :mock => true).get(:expects => 200)
-      true
-    end
-  end
-
-  Excon.stubs.clear
-
-  tests("stub({}, {:status => 404, :body => 'Not Found'}") do
-    connection = nil
-
-    tests("request(:expects => 200, :method => :get, :path => '/')").raises(Excon::Errors::NotFound) do
-      connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-      Excon.stub({}, {:status => 404, :body => 'Not Found'})
-
-      connection.request(:expects => 200, :method => :get, :path => '/')
-    end
-
-    tests("Expects exception should contain response object").returns(Excon::Response) do
-      begin
-        connection.request(:expects => 200, :method => :get, :path => '/')
-      rescue Excon::Errors::NotFound => e
-        e.response.class
-      end
-    end
-
-    test("request(:expects => 200, :method => :get, :path => '/') with block does not invoke the block since it raises an error") do
-      block_called = false
-      begin
-        response_block = lambda do |_,_,_|
-          block_called = true
-        end
-        connection.request(:expects => 200, :method => :get, :path => '/', :response_block => response_block)
-      rescue Excon::Errors::NotFound
-      end
-      !block_called
-    end
-
-    Excon.stubs.clear
-
-  end
-
-  tests("stub_for({})") do
-    tests("stub_for({})").returns([{}, {}]) do
-      Excon.new('http://127.0.0.1:9292', :mock => true)
-      Excon.stub({}, {})
-
-      Excon.stub_for({})
-    end
-
-    Excon.stubs.clear
-  end
-
-  tests("unstub({})") do
-    connection = nil
-
-    tests("unstub({})").returns([{}, {}]) do
-      connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-      Excon.stub({}, {})
-
-      Excon.unstub({})
-    end
-
-    tests("request(:method => :get)").raises(Excon::Errors::StubNotFound) do
-      connection.request(:method => :get)
-    end
-
-    Excon.stubs.clear
-  end
-
-  tests("global stubs") do
-    connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-    Excon.stub({}, {:body => '1'})
-    t = Thread.new do
-      Excon.stub({}, {:body => '2'})
-      connection.request(:method => :get).body
-    end
-    tests("get on a different thread").returns('2') do
-      t.join.value
-    end
-    tests("get on main thread").returns('2') do
-      connection.request(:method => :get).body
-    end
-    Excon.stubs.clear
-  end
-
-  tests("thread-local stubs") do
-    original_stubs_value = Excon.defaults[:stubs]
-    Excon.defaults[:stubs] = :local
-
-    connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-    Excon.stub({}, {:body => '1'})
-    t = Thread.new do
-      Excon.stub({}, {:body => '2'})
-      connection.request(:method => :get).body
-    end
-    tests("get on a different thread").returns('2') do
-      t.join.value
-    end
-    tests("get on main thread").returns('1') do
-      connection.request(:method => :get).body
-    end
-    Excon.stubs.clear
-
-    Excon.defaults[:stubs] = original_stubs_value
-  end
-
-  env_restore
-end