excon 0.52.0 → 0.53.0

data/spec/excon/test/server_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Excon::Test::Server do
+  
+  context 'when the web server is webrick' do
+    it_should_behave_like "a excon test server", :webrick, 'basic.ru'
+  end
+
+
+  context 'when the web server is unicorn' do 
+    context 'bound to a tcp socket' do
+      it_should_behave_like "a excon test server", :unicorn, 'streaming.ru'
+    end
+
+    context "bound to a unix socket" do
+      socket_uri = 'unix:///tmp/unicorn.socket'
+      it_should_behave_like "a excon test server", :unicorn, 'streaming.ru', socket_uri
+    end
+  end
+
+  context 'when the web server is puma' do
+    it_should_behave_like "a excon test server", :puma, 'streaming.ru'
+  end
+
+  context 'when the web server is a executable' do
+    it_should_behave_like "a excon test server", :exec, 'good.rb'
+  end
+end

data/spec/helpers/file_path_helpers.rb

@@ -0,0 +1,22 @@
+# Todo: s/tests/specs when migration is complete
+def get_abs_path(*parts)
+  File.join(File.expand_path('../../..', __FILE__), 'tests', *parts)
+end
+
+def data_path(*parts)
+  get_abs_path('data', *parts)
+end
+
+def rackup_path(*parts)
+  get_abs_path('rackups', *parts)
+end
+
+def webrick_path(*parts) rackup_path(*parts); end
+
+def unicorn_path(*parts) rackup_path(*parts); end
+
+def puma_path(*parts) rackup_path(*parts); end
+
+def exec_path(*parts)
+  get_abs_path('servers', *parts)
+end

data/spec/requests/basic_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Excon::Connection do
+  include_context('test server', :webrick, 'basic.ru', before: :start, after: :stop)
+  context 'when an explicit uri is passed' do
+    let(:conn) do
+      Excon::Connection.new(host: '127.0.0.1',
+                                           hostname: '127.0.0.1',
+                                           nonblock: false,
+                                           port: 9292,
+                                           scheme: 'http',
+                                           ssl_verify_peer: false)
+    end
+
+    describe '.new' do
+      it 'returns an instance' do
+        expect(conn).to be_instance_of Excon::Connection
+      end
+    end
+
+    context "when :method is :get and :path is /content-length/100" do
+      describe "#request" do
+        let(:response) do
+          response = conn.request(method: :get, path: '/content-length/100')
+        end
+        it 'returns an Excon::Response' do
+          expect(response).to be_instance_of Excon::Response
+        end
+        describe Excon::Response do
+          describe '#status' do
+            it 'returns 200' do
+              expect(response.status).to eq 200
+            end
+          end
+        end
+      end
+    end
+    include_examples 'a basic client'
+  end
+end

data/spec/requests/eof_requests_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Excon do
+  context "when dispatching requests" do
+    context('to a server that does not supply response headers') do
+      include_context("test server", :exec, 'bad.rb', :before => :start, :after => :stop )
+      before(:all) do
+        @conn = Excon.new('http://127.0.0.1:9292')
+      end
+
+      context('when no block is given') do
+        it 'should rescue from an EOFError and return response' do
+          body = @conn.request(:method => :get, :path => '/eof/no_content_length_and_no_chunking').body
+        expect(body).to eq 'hello'
+        end
+      end
+
+      context('when a block is given') do
+        it 'should rescue from EOFError and return response' do
+          body = ""
+          response_block = lambda {|chunk, remaining, total| body << chunk }
+          @conn.request(:method => :get, :path => '/eof/no_content_length_and_no_chunking', :response_block => response_block)
+          expect(body).to eq 'hello'
+        end
+      end
+    end
+
+    context('to a server that prematurely aborts the request with no response') do
+      include_context("test server", :exec, 'eof.rb', :before => :start, :after => :stop )
+
+      it 'should raise an EOFError' do
+        expect { Excon.get('http://127.0.0.1:9292/eof') }.to raise_error(Excon::Errors::SocketError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,126 +1,24 @@
 require 'excon'
 require 'excon/test/server'
+require 'json'
 
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause
-# this file to always be loaded, without a need to explicitly require it in any
-# files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, consider making
-# a separate helper file that requires the additional dependencies and performs
-# the additional setup, and require it from the spec files that actually need
-# it.
-#
-# The `.rspec` file also contains a few flags that are not defaults but that
-# users commonly want.
-#
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
   config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    #     be_bigger_than(2).and_smaller_than(4).description
-    #     # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #     # => "be bigger than 2"
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end
 
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
-  config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
-    mocks.verify_partial_doubles = true
+ config.mock_with :rspec do |mocks|
+   mocks.verify_partial_doubles = true
   end
 
-  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
-  # have no way to turn it off -- the option exists only for backwards
-  # compatibility in RSpec 3). It causes shared context metadata to be
-  # inherited by the metadata hash of host groups and examples, rather than
-  # triggering implicit auto-inclusion in groups with matching metadata.
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-
-# The settings below are suggested to provide a good initial experience
-# with RSpec, but feel free to customize to your heart's content.
-=begin
-  # This allows you to limit a spec run to individual examples or groups
-  # you care about by tagging them with `:focus` metadata. When nothing
-  # is tagged with `:focus`, all examples get run. RSpec also provides
-  # aliases for `it`, `describe`, and `context` that include `:focus`
-  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
-  config.filter_run_when_matching :focus
-
-  # Allows RSpec to persist some state between runs in order to support
-  # the `--only-failures` and `--next-failure` CLI options. We recommend
-  # you configure your source control system to ignore this file.
-  config.example_status_persistence_file_path = "spec/examples.txt"
-
-  # Limits the available syntax to the non-monkey patched syntax that is
-  # recommended. For more details, see:
-  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
-  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
-  config.disable_monkey_patching!
-
-  # This setting enables warnings. It's recommended, but in some cases may
-  # be too noisy due to issues in dependencies.
-  config.warnings = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
   if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
     config.default_formatter = 'doc'
   end
-
-  # Print the 10 slowest examples and example groups at the
-  # end of the spec run, to help surface which specs are running
-  # particularly slow.
-  config.profile_examples = 10
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-=end
-
-end
-
-# Todo: s/tests/specs when migration is complete
-def get_abs_path(*parts)
-  File.join(File.expand_path('../..', __FILE__), 'tests', *parts)
-end
-
-def rackup_path(*parts)
-  get_abs_path('rackups', *parts)
 end
 
-def webrick_path(*parts) rackup_path(*parts); end
-
-def unicorn_path(*parts) rackup_path(*parts); end
+# Load helpers
+Dir["./spec/helpers/**/*.rb"].sort.each { |f| require f}
 
-def puma_path(*parts) rackup_path(*parts); end
-
-def exec_path(*parts)
-  get_abs_path('servers', *parts)
-end
+# Load shared examples and contexts
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f}

data/spec/support/shared_contexts/test_server_context.rb

@@ -0,0 +1,83 @@
+# TODO: Clean up this doc and dry up the conditionals
+#
+# Required params:
+#   plugin (e.g., webrick, unicorn, etc)
+#   file (e.g. a rackup )
+#
+# Optional params:
+# optional paramters may given as a hash
+# opts may contain a bind argument
+# opts may also contain before and after options
+#
+# In its simplest form:
+# { :before => :start, :after => :stop }
+#
+# With lambdas, which recieve @server as an argument
+# { before: lambda {|s| s.start }, after: lambda { |s| s.stop} }
+#
+# In both the cases above, before defaults to before(:all)
+# This can be circumvented with a Hash
+# { before: { :context => :start }, after: { :context => :stop } }
+# or
+# { before: { context: lambda { |s| s.start } }, after: { context: lambda { |s| s.stop } } }
+
+shared_context "test server" do |plugin, file, opts = {}|
+  plugin = plugin.to_sym unless plugin.is_a? Symbol
+  if plugin == :unicorn && RUBY_PLATFORM == "java"
+    before { skip("until unicorn supports jruby") }
+  end
+  abs_file = Object.send("#{plugin}_path", file)
+  args = { plugin => abs_file}
+  args[:bind] = opts[:bind] if opts.key? :bind
+
+
+  before_hook = opts.key?(:before) && (opts[:before].is_a?(Symbol) || opts[:before].is_a?(Proc) || opts[:before].is_a?(Hash))
+
+  if before_hook && opts[:before].is_a?(Hash)
+    event = opts[:before].keys.first
+    before(event) {
+      @server = Excon::Test::Server.new(args)
+      if opts[:before][event].is_a? Symbol
+        @server.send(opts[:before][event])
+      else
+        opts[:before][event].call(@server)
+      end
+    }
+  elsif
+    before(:all) {
+      @server = Excon::Test::Server.new(args)
+      before_hook = opts.key?(:before) && (opts[:before].is_a?(Symbol) || opts[:before].is_a?(Proc) || opts[:before].is_a?(Hash))
+
+      if before_hook
+        if opts[:before].is_a? Symbol
+          @server.send(opts[:before])
+        else
+          opts[:before].call(@server)
+        end
+      end
+    }
+  end
+
+  after_hook = opts.key?(:after) && (opts[:after].is_a?(Symbol) || opts[:after].is_a?(Proc) || opts[:after].is_a?(Hash))
+
+  if after_hook && opts[:after].is_a?(Hash)
+      event = opts[:after].keys.first
+      after(event) {
+        if opts[:after][event].is_a? Symbol
+          @server.send(opts[:after][event])
+        else
+          opts[:after][event].call(@server)
+        end
+      }
+  elsif after_hook
+    after(:all) {
+      if opts[:after].is_a? Symbol
+        @server.send(opts[:after])
+      elsif opts[:after].is_a? Hash
+
+      else
+        opts[:after].call(@server)
+      end
+    }
+  end
+end

data/spec/support/shared_examples/shared_example_for_clients.rb

@@ -0,0 +1,207 @@
+shared_examples_for 'a basic client' do |url = 'http://127.0.0.1:9292', opts = {}|
+  # TODO: Ditch iterator and manually write a context for each set of options
+  ([true, false] * 2).combination(2).to_a.uniq.each do |nonblock, persistent|
+    context "when nonblock is #{nonblock} and persistent is #{persistent}" do
+      opts = opts.merge(ssl_verify_peer: false, nonblock: nonblock, persistent: persistent)
+
+      let(:conn) { Excon.new(url, opts) }
+
+      context 'when :method is get and :path is /content-length/100' do
+        describe '#request' do
+          let(:response) do
+            conn.request(method: :get, path: '/content-length/100')
+          end
+
+          it 'returns an Excon::Response' do
+            expect(response).to be_instance_of Excon::Response
+          end
+          describe Excon::Response do
+            describe '#status' do
+              it 'returns 200' do
+                expect(response.status).to eq 200
+              end
+
+              it '#status returns 200' do
+                expect(response[:status]).to eq 200
+              end
+            end
+            describe '#headers' do
+              it '["Content-Length"] returns 100' do
+                expect(response.headers['Content-Length']).to eq '100'
+              end
+              it '["Content-Type"] returns  "text/html;charset=utf-8"' do
+                expect(response.headers['Content-Type']).to eq 'text/html;charset=utf-8'
+              end
+
+              it "['Date'] returns a valid date" do
+                if RUBY_PLATFORM == 'java' && conn.data[:scheme] == Excon::UNIX
+                  skip('until puma responds with a date header')
+                else
+                  time = Time.parse(response.headers['Date'])
+                  expect(time.is_a?(Time)).to be true
+                end
+              end
+
+              it "['Server'] matches /^WEBrick/" do
+                pending('until unix_socket response has server header') if conn.data[:scheme] == Excon::UNIX
+                expect(!!(response.headers['Server'] =~ /^WEBrick/)).to be true
+              end
+
+              it "['Custom'] returns Foo: bar" do
+                expect(response.headers['Custom']).to eq 'Foo: bar'
+              end
+            end
+            describe '#remote_ip' do
+              it 'returns 127.0.0.1' do
+                pending('until pigs can fly') if conn.data[:scheme] == Excon::UNIX
+                expect(response.remote_ip).to eq '127.0.0.1'
+              end
+            end
+          end
+
+          context('when tcp_nodelay is true') do
+            describe '#request' do
+              response = nil
+              options = opts.merge(ssl_verify_peer: false, nonblock: nonblock, tcp_nodelay: true)
+              connection = Excon.new(url, options)
+
+              it 'returns an Excon::Response' do
+                expect do
+                  response = connection.request(method: :get, path: '/content-length/100')
+                end.to_not raise_error
+              end
+
+              describe Excon::Response do
+                describe '#body' do
+                  describe '.status' do
+                    it '#returns 200' do
+                      expect(response.status).to eq 200
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        context 'when utilizing deprecated block usage' do
+          describe '#request' do
+            data = []
+            it 'yields with a chunk, remaining length, and total length' do
+              expect do
+                conn.request(method: :get, path: '/content-length/100') do |chunk, remaining_length, total_length|
+                  data = [chunk, remaining_length, total_length]
+                end
+              end.to_not raise_error
+            end
+            it 'completes with expected data' do
+              expect(data).to eq ['x' * 100, 0, 100]
+            end
+          end
+        end
+
+        context 'when utilizing response_block usage' do
+          describe '#request' do
+            data = []
+            it 'yields a chunk, remaining length, and total_length' do
+              response_block = lambda do |chunk, remaining_length, total_length|
+                data = [chunk, remaining_length, total_length]
+              end
+              expect do
+                conn.request(method: :get, path: '/content-length/100', response_block: response_block)
+              end.to_not raise_error
+            end
+            it 'completes with expected data' do
+              expect(data).to eq ['x' * 100, 0, 100]
+            end
+          end
+        end
+        context 'when method is :post' do
+          context 'when :path is /body-sink' do
+            context 'when a body parameter is supplied' do
+              response = nil
+              it 'returns an Excon::Response' do
+                response = conn.request(method: :post, path: '/body-sink', headers: { 'Content-Type' => 'text/plain' }, body: 'x' * 5_000_000)
+                expect(response).to be_instance_of Excon::Response
+              end
+              describe Excon::Response do
+                describe '#body' do
+                  it 'equals "5000000"' do
+                    expect(response.body).to eq '5000000'
+                  end
+                end
+              end
+            end
+            context 'when the body parameter is an empty string' do
+              response = nil
+
+              it 'returns an Excon::Response' do
+                response = conn.request(method: :post, path: '/body-sink', headers: { 'Content-Type' => 'text/plain' }, body: '')
+                expect(response).to be_instance_of Excon::Response
+              end
+              describe Excon::Response do
+                describe '#body' do
+                  it 'equals "0"' do
+                    expect(response.body).to eq '0'
+                  end
+                end
+              end
+            end
+          end
+
+          context 'when :path is /echo' do
+            context('when a file handle is the body paramter') do
+              describe Excon::Response do
+                it '#body equals "x" * 100 + "\n"' do
+                  file_path = data_path('xs')
+                  response = conn.request(method: :post, path: '/echo', body: File.open(file_path))
+                  expect(response.body).to eq 'x' * 100 + "\n"
+                end
+              end
+            end
+
+            context 'when a string is the body paramter' do
+              context 'without request_block' do
+                describe Excon::Response do
+                  it "#body equals 'x' * 100)" do
+                    response = conn.request(method: :post, path: '/echo', body: 'x' * 100)
+                    expect(response.body).to eq 'x' * 100
+                  end
+                end
+              end
+
+              context 'when a request_block paramter is supplied' do
+                describe Excon::Response do
+                  it "#body equals'x' * 100" do
+                    data = ['x'] * 100
+                    request_block = lambda do
+                      data.shift.to_s
+                    end
+                    response = conn.request(method: :post, path: '/echo', request_block: request_block)
+                    expect(response.body).to eq 'x' * 100
+                  end
+                end
+              end
+
+              context('when a multi-byte string is the body paramter') do
+                body = "\xC3\xBC" * 100
+                headers = { 'Custom' => body.dup }
+                if RUBY_VERSION >= '1.9'
+                  body.force_encoding('BINARY')
+                  headers['Custom'].force_encoding('UTF-8')
+                end
+                describe Excon::Response do
+                  it '#body properly concatenates request+headers and body' do
+                    response = conn.request(method: :post, path: '/echo',
+                                            headers: headers, body: body)
+                    expect(response.body).to eq body
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end