excon 0.62.0 → 0.85.0

data/tests/middlewares/canned_response_tests.rb

@@ -1,34 +0,0 @@
-Shindo.tests("Excon support for middlewares that return canned responses") do
-  the_body = "canned"
-
-  canned_response_middleware = Class.new(Excon::Middleware::Base) do
-    define_method :request_call do |params|
-      params[:response] = {
-        :body     => the_body,
-        :headers  => {},
-        :status   => 200
-      }
-      super(params)
-    end
-  end
-
-  tests('does not mutate the canned response body').returns(the_body) do
-    Excon.get(
-      'http://some-host.com/some-path',
-      :middlewares    => [canned_response_middleware] + Excon.defaults[:middlewares]
-    ).body
-  end
-
-  tests('yields non-mutated body to response_block').returns(the_body) do
-    body = ''
-    response_block = lambda { |chunk, _, _| body << chunk }
-    Excon.get(
-      'http://some-host.com/some-path',
-      :middlewares    => [canned_response_middleware] + Excon.defaults[:middlewares],
-      :response_block => response_block
-    )
-    body
-  end
-
-end
-

data/tests/middlewares/capture_cookies_tests.rb

@@ -1,34 +0,0 @@
-Shindo.tests("Excon redirecting with cookie preserved") do
-  env_init
-
-  with_rackup('redirecting_with_cookie.ru') do
-    tests('second request will send cookies set by the first').returns('ok') do
-      Excon.get(
-        'http://127.0.0.1:9292',
-        :path         => '/sets_cookie',
-        :middlewares  => Excon.defaults[:middlewares] + [Excon::Middleware::CaptureCookies, Excon::Middleware::RedirectFollower]
-      ).body
-    end
-
-    tests('second request will send multiple cookies set by the first').returns('ok') do
-      Excon.get(
-        'http://127.0.0.1:9292',
-        :path         => '/sets_multi_cookie',
-        :middlewares  => Excon.defaults[:middlewares] + [Excon::Middleware::CaptureCookies, Excon::Middleware::RedirectFollower]
-      ).body
-    end
-  end
-
-  with_rackup('redirecting.ru') do
-    tests("runs normally when there are no cookies set").returns('ok') do
-      Excon.post(
-        'http://127.0.0.1:9292',
-        :path         => '/first',
-        :middlewares  => Excon.defaults[:middlewares] + [Excon::Middleware::CaptureCookies, Excon::Middleware::RedirectFollower],
-        :body => "a=Some_content"
-      ).body
-    end
-  end
-
-  env_restore
-end

data/tests/middlewares/decompress_tests.rb

@@ -1,157 +0,0 @@
-Shindo.tests('Excon Decompress Middleware') do
-  env_init
-
-  with_server('good') do
-
-    before do
-      @connection ||= Excon.new(
-        'http://127.0.0.1:9292/echo/content-encoded',
-        :method => :post,
-        :body => 'hello world',
-        :middlewares => Excon.defaults[:middlewares] + [Excon::Middleware::Decompress]
-      )
-    end
-
-    tests('gzip') do
-      resp = nil
-
-      tests('response body decompressed').returns('hello world') do
-        resp = @connection.request(
-          :headers => { 'Accept-Encoding' => 'gzip, deflate;q=0' }
-        )
-        resp[:body]
-      end
-
-      tests('server sent content-encoding').returns('gzip') do
-        resp[:headers]['Content-Encoding-Sent']
-      end
-
-      tests('removes processed encoding from header').returns('') do
-        resp[:headers]['Content-Encoding']
-      end
-
-      tests('empty response body').returns('') do
-        resp = @connection.request(:body => '')
-        resp[:body]
-      end
-    end
-
-    tests('deflate') do
-      resp = nil
-
-      tests('response body decompressed').returns('hello world') do
-        resp = @connection.request(
-          :headers => { 'Accept-Encoding' => 'gzip;q=0, deflate' }
-        )
-        resp[:body]
-      end
-
-      tests('server sent content-encoding').returns('deflate') do
-        resp[:headers]['Content-Encoding-Sent']
-      end
-
-      tests('removes processed encoding from header').returns('') do
-        resp[:headers]['Content-Encoding']
-      end
-    end
-
-    tests('with pre-encoding') do
-      resp = nil
-
-      tests('server sent content-encoding').returns('other, gzip') do
-        resp = @connection.request(
-          :headers => { 'Accept-Encoding' => 'gzip, deflate;q=0',
-                        'Content-Encoding-Pre' => 'other' }
-        )
-        resp[:headers]['Content-Encoding-Sent']
-      end
-
-      tests('processed encoding removed from header').returns('other') do
-        resp[:headers]['Content-Encoding']
-      end
-
-      tests('response body decompressed').returns('hello world') do
-        resp[:body]
-      end
-
-    end
-
-    tests('with post-encoding') do
-      resp = nil
-
-      tests('server sent content-encoding').returns('gzip, other') do
-        resp = @connection.request(
-          :headers => { 'Accept-Encoding' => 'gzip, deflate;q=0',
-                        'Content-Encoding-Post' => 'other' }
-        )
-        resp[:headers]['Content-Encoding-Sent']
-      end
-
-      tests('unprocessed since last applied is unknown').returns('gzip, other') do
-        resp[:headers]['Content-Encoding']
-      end
-
-      tests('response body still compressed').returns('hello world') do
-        Zlib::GzipReader.new(StringIO.new(resp[:body])).read
-      end
-
-    end
-
-    tests('with a :response_block') do
-      captures = nil
-      resp = nil
-
-      tests('server sent content-encoding').returns('gzip') do
-        captures = capture_response_block do |block|
-          resp = @connection.request(
-            :headers => { 'Accept-Encoding' => 'gzip'},
-            :response_block => block
-          )
-        end
-        resp[:headers]['Content-Encoding-Sent']
-      end
-
-      tests('unprocessed since :response_block was used').returns('gzip') do
-        resp[:headers]['Content-Encoding']
-      end
-
-      tests(':response_block passed unprocessed data').returns('hello world') do
-        body = captures.map {|capture| capture[0] }.join
-        Zlib::GzipReader.new(StringIO.new(body)).read
-      end
-
-    end
-
-    tests('adds Accept-Encoding if needed') do
-
-      tests('without a :response_block').returns('deflate, gzip') do
-        resp = Excon.post(
-          'http://127.0.0.1:9292/echo/request',
-          :body => 'hello world',
-          :middlewares => Excon.defaults[:middlewares] +
-                          [Excon::Middleware::Decompress]
-        )
-        request = Marshal.load(resp.body)
-        request[:headers]['Accept-Encoding']
-      end
-
-      tests('with a :response_block').returns(nil) do
-        captures = capture_response_block do |block|
-          Excon.post(
-            'http://127.0.0.1:9292/echo/request',
-            :body => 'hello world',
-            :response_block => block,
-            :middlewares => Excon.defaults[:middlewares] +
-                            [Excon::Middleware::Decompress]
-          )
-        end
-        request = Marshal.load(captures.map {|capture| capture[0] }.join)
-        request[:headers]['Accept-Encoding']
-      end
-
-    end
-
-  end
-
-  env_restore
-end

data/tests/middlewares/escape_path_tests.rb

@@ -1,36 +0,0 @@
-Shindo.tests('Excon Decompress Middleware') do
-  env_init
-  with_rackup('basic.ru') do
-    tests('encoded uri passed to connection') do
-      tests('GET /echo%20dirty').returns(200) do
-        connection = Excon::Connection.new({
-          :host             => '127.0.0.1',
-          :hostname         => '127.0.0.1',
-          :middlewares      => Excon.defaults[:middlewares] + [Excon::Middleware::EscapePath],
-          :nonblock         => false,
-          :port             => 9292,
-          :scheme           => 'http',
-          :ssl_verify_peer  => false
-        })
-        response = connection.request(:method => :get, :path => '/echo%20dirty')
-        response[:status]
-      end
-    end
-
-    tests('unencoded uri passed to connection') do
-      tests('GET /echo dirty').returns(200) do
-        connection = Excon::Connection.new({
-          :host             => '127.0.0.1',
-          :hostname         => '127.0.0.1',
-          :middlewares      => Excon.defaults[:middlewares] + [Excon::Middleware::EscapePath],
-          :nonblock         => false,
-          :port             => 9292,
-          :scheme           => 'http',
-          :ssl_verify_peer  => false
-        })
-        response = connection.request(:method => :get, :path => '/echo dirty')
-        response[:status]
-      end
-    end
-  end
-end

data/tests/middlewares/idempotent_tests.rb

@@ -1,206 +0,0 @@
-Shindo.tests('Excon request idempotencey') do
-
-  before do
-    @connection = Excon.new('http://127.0.0.1:9292', :mock => true)
-  end
-
-  after do
-    # flush any existing stubs after each test
-    Excon.stubs.clear
-  end
-
-  tests("Non-idempotent call with an erroring socket").raises(Excon::Errors::SocketError) do
-    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
-    }
-
-    @connection.request(:method => :get, :path => '/some-path')
-  end
-
-  tests("Idempotent request with socket erroring first 3 times").returns(200) do
-    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
-    }
-
-    response = @connection.request(:method => :get, :idempotent => true, :path => '/some-path')
-    response.status
-  end
-
-  tests("Idempotent request with socket erroring first 5 times").raises(Excon::Errors::SocketError) do
-    run_count = 0
-    Excon.stub({:method => :get}) { |params|
-      run_count += 1
-      if run_count <= 5 # First 5 calls fail.
-        raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
-      else
-        {:body => params[:body], :headers => params[:headers], :status => 200}
-      end
-    }
-
-    response = @connection.request(:method => :get, :idempotent => true, :path => '/some-path')
-    response.status
-  end
-
-  tests("Lowered retry limit with socket erroring first time").returns(200) do
-    run_count = 0
-    Excon.stub({:method => :get}) { |params|
-      run_count += 1
-      if run_count <= 1 # First call fails.
-        raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
-      else
-        {:body => params[:body], :headers => params[:headers], :status => 200}
-      end
-    }
-
-    response = @connection.request(:method => :get, :idempotent => true, :path => '/some-path', :retry_limit => 2)
-    response.status
-  end
-
-  tests("Lowered retry limit with socket erroring first 3 times").raises(Excon::Errors::SocketError) do
-    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
-    }
-
-    response = @connection.request(:method => :get, :idempotent => true, :path => '/some-path', :retry_limit => 2)
-    response.status
-  end
-
-  tests("Raised retry limit with socket erroring first 5 times").returns(200) do
-    run_count = 0
-    Excon.stub({:method => :get}) { |params|
-      run_count += 1
-      if run_count <= 5 # First 5 calls fail.
-        raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
-      else
-        {:body => params[:body], :headers => params[:headers], :status => 200}
-      end
-    }
-
-    response = @connection.request(:method => :get, :idempotent => true, :path => '/some-path', :retry_limit => 8)
-    response.status
-  end
-
-  tests("Raised retry limit with socket erroring first 9 times").raises(Excon::Errors::SocketError) do
-    run_count = 0
-    Excon.stub({:method => :get}) { |params|
-      run_count += 1
-      if run_count <= 9 # First 9 calls fail.
-        raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
-      else
-        {:body => params[:body], :headers => params[:headers], :status => 200}
-      end
-    }
-
-    response = @connection.request(:method => :get, :idempotent => true, :path => '/some-path', :retry_limit => 8)
-    response.status
-  end
-
-  tests("Retry limit in constructor with socket erroring first 5 times").returns(200) do
-    run_count = 0
-    Excon.stub({:method => :get}) { |params|
-      run_count += 1
-      if run_count <= 5 # First 5 calls fail.
-        raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
-      else
-        {:body => params[:body], :headers => params[:headers], :status => 200}
-      end
-    }
-
-    response = @connection.request(:method => :get, :idempotent => true, :path => '/some-path', :retry_limit => 6)
-    response.status
-  end
-
-  tests("Retry limit and sleep in constructor with socket erroring first 2 times").returns(200) do
-    run_count = 0
-    Excon.stub({:method => :get}) { |params|
-      run_count += 1
-      if run_count <= 2 # First 5 calls fail.
-        raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
-      else
-        {:body => params[:body], :headers => params[:headers], :status => 200}
-      end
-    }
-
-
-    # NOTE: A short :retry_interval will avoid slowing down the tests.
-    response = @connection.request(:method => :get, :idempotent => true, :path => '/some-path', :retry_limit => 3, :retry_interval => 0.1)
-    response.status
-  end
-
-  tests("Retry limit and sleep in constructor with socket erroring first 2 times").raises(Excon::Errors::SocketError) do
-    run_count = 0
-    Excon.stub({:method => :get}) { |params|
-      run_count += 1
-      if run_count <= 2 # First 5 calls fail.
-        raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
-      else
-        {:body => params[:body], :headers => params[:headers], :status => 200}
-      end
-    }
-
-    # NOTE: A short :retry_interval will avoid slowing down the tests.
-    response = @connection.request(:method => :get, :idempotent => true, :path => '/some-path', :retry_limit => 2, :retry_interval => 0.1)
-    response.status
-  end
-
-  class Block
-    attr_reader :rewound
-    def initialize
-      @rewound = false
-    end
-    def call(_)
-    end
-    def rewind
-      @rewound = true
-    end
-  end
-
-  tests("request_block rewound").returns(true) do
-    run_count = 0
-    Excon.stub({:method => :get}) { |params|
-      run_count += 1
-      if run_count <= 1 # First call fails.
-        raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
-      else
-        {:body => params[:body], :headers => params[:headers], :status => 200}
-      end
-    }
-    request_block = Block.new
-    @connection.request(:method => :get, :idempotent => true, :path => '/some-path', :request_block => request_block, :retry_limit => 2, :retry_interval => 0.1)
-    request_block.rewound
-  end
-
-  tests("response_block rewound").returns(true) do
-    run_count = 0
-    Excon.stub({:method => :get}) { |params|
-      run_count += 1
-      if run_count <= 1 # First call fails.
-        raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
-      else
-        {:body => params[:body], :headers => params[:headers], :status => 200}
-      end
-    }
-    response_block = Block.new
-    @connection.request(:method => :get, :idempotent => true, :path => '/some-path', :response_block => response_block, :retry_limit => 2, :retry_interval => 0.1)
-    response_block.rewound
-  end
-
-end