http 0.5.1 → 0.6.0.pre

data/spec/http/options/body_spec.rb

@@ -1,18 +1,17 @@
 require 'spec_helper'
 
-describe HTTP::Options, "body" do
+describe HTTP::Options, 'body' do
 
-  let(:opts){ HTTP::Options.new }
+  let(:opts) { HTTP::Options.new }
 
   it 'defaults to nil' do
-    expect(opts.body).to be_nil
+    expect(opts.body).to be nil
   end
 
   it 'may be specified with with_body' do
-    opts2 = opts.with_body("foo")
-    expect(opts.body).to be_nil
-    expect(opts2.body).to eq("foo")
+    opts2 = opts.with_body('foo')
+    expect(opts.body).to be nil
+    expect(opts2.body).to eq('foo')
   end
 
 end
-

data/spec/http/options/form_spec.rb

@@ -1,18 +1,17 @@
 require 'spec_helper'
 
-describe HTTP::Options, "form" do
+describe HTTP::Options, 'form' do
 
-  let(:opts){ HTTP::Options.new }
+  let(:opts) { HTTP::Options.new }
 
   it 'defaults to nil' do
-    expect(opts.form).to be_nil
+    expect(opts.form).to be nil
   end
 
   it 'may be specified with with_form_data' do
     opts2 = opts.with_form(:foo => 42)
-    expect(opts.form).to be_nil
+    expect(opts.form).to be nil
     expect(opts2.form).to eq(:foo => 42)
   end
 
 end
-

data/spec/http/options/headers_spec.rb

@@ -1,30 +1,22 @@
 require 'spec_helper'
 
-describe HTTP::Options, "headers" do
+describe HTTP::Options, 'headers' do
 
-  let(:opts)       { HTTP::Options.new }
-  let(:user_agent) { "RubyHTTPGem/#{HTTP::VERSION}" }
+  let(:opts) { HTTP::Options.new }
 
-  it 'defaults to just the user agent' do
-    expect(opts.headers).to eq("User-Agent" => user_agent)
+  it 'defaults to be empty' do
+    expect(opts.headers).to be_empty
   end
 
   it 'may be specified with with_headers' do
-    opts2 = opts.with_headers("accept" => "json")
-    expect(opts.headers).to eq("User-Agent" => user_agent)
-    expect(opts2.headers).to eq("accept" => "json", "User-Agent" => user_agent)
+    opts2 = opts.with_headers('accept' => 'json')
+    expect(opts.headers).to be_empty
+    expect(opts2.headers).to eq([%w[Accept json]])
   end
 
   it 'accepts any object that respond to :to_hash' do
-    x = Struct.new(:to_hash).new("accept" => "json")
-    expect(opts.with_headers(x).headers["accept"]).to eq("json")
-  end
-
-  it 'recognizes invalid headers' do
-    expect {
-      opts.with_headers(self)
-    }.to raise_error(ArgumentError)
+    x = Struct.new(:to_hash).new('accept' => 'json')
+    expect(opts.with_headers(x).headers['accept']).to eq('json')
   end
 
 end
-

data/spec/http/options/json_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe HTTP::Options, 'json' do
+
+  let(:opts) { HTTP::Options.new }
+
+  it 'defaults to nil' do
+    expect(opts.json).to be nil
+  end
+
+  it 'may be specified with with_json data' do
+    opts2 = opts.with_json(:foo => 42)
+    expect(opts.json).to be nil
+    expect(opts2.json).to eq(:foo => 42)
+  end
+
+end

data/spec/http/options/merge_spec.rb

@@ -1,9 +1,7 @@
 require 'spec_helper'
 
-describe HTTP::Options, "merge" do
-
-  let(:opts)       { HTTP::Options.new }
-  let(:user_agent) { "RubyHTTPGem/#{HTTP::VERSION}" }
+describe HTTP::Options, 'merge' do
+  let(:opts) { HTTP::Options.new }
 
   it 'supports a Hash' do
     old_response = opts.response
@@ -23,30 +21,31 @@ describe HTTP::Options, "merge" do
       :response  => :body,
       :params      => {:baz => 'bar'},
       :form      => {:foo => 'foo'},
-      :body      => "body-foo",
-      :headers   => {:accept  => "json",  :foo => 'foo'},
-      :proxy     => {},
-      :callbacks => {:request => ["common"], :response => ["foo"]})
+      :body      => 'body-foo',
+      :json      => {:foo => 'foo'},
+      :headers   => {:accept  => 'json',  :foo => 'foo'},
+      :proxy     => {})
+
     bar = HTTP::Options.new(
       :response  => :parsed_body,
       :params      => {:plop => 'plip'},
       :form      => {:bar => 'bar'},
-      :body      => "body-bar",
-      :headers   => {:accept  => "xml", :bar => 'bar'},
-      :proxy     => {:proxy_address => "127.0.0.1", :proxy_port => 8080},
-      :callbacks => {:request => ["common"], :response => ["bar"]})
+      :body      => 'body-bar',
+      :json      => {:bar => 'bar'},
+      :headers   => {:accept  => 'xml', :bar => 'bar'},
+      :proxy     => {:proxy_address => '127.0.0.1', :proxy_port => 8080})
+
     expect(foo.merge(bar).to_hash).to eq(
       :response  => :parsed_body,
-      :params=>{:plop=>"plip"},
+      :params    => {:plop => 'plip'},
       :form      => {:bar => 'bar'},
-      :body      => "body-bar",
-      :headers   => {:accept  => "xml", :foo => "foo", :bar => 'bar', "User-Agent" => user_agent},
-      :proxy     => {:proxy_address => "127.0.0.1", :proxy_port => 8080},
-      :callbacks => {:request => ["common"], :response => ["foo", "bar"]},
+      :body      => 'body-bar',
+      :json      => {:bar => 'bar'},
+      :headers   => {'Accept'  => 'xml', 'Foo' => 'foo', 'Bar' => 'bar'},
+      :proxy     => {:proxy_address => '127.0.0.1', :proxy_port => 8080},
       :follow => nil,
       :socket_class     => described_class.default_socket_class,
       :ssl_socket_class => described_class.default_ssl_socket_class,
-      :ssl_context      => nil
-    )
+      :ssl_context      => nil)
   end
 end

data/spec/http/options/new_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
-describe HTTP::Options, "new" do
-  let(:user_agent) { "RubyHTTPGem/#{HTTP::VERSION}" }
-
+describe HTTP::Options, 'new' do
   it 'supports a Options instance' do
     opts = HTTP::Options.new
     expect(HTTP::Options.new(opts)).to eq(opts)
@@ -15,30 +13,18 @@ describe HTTP::Options, "new" do
     end
 
     it 'coerces :headers correctly' do
-      opts = HTTP::Options.new(:headers => {:accept => "json"})
-      expect(opts.headers).to eq(:accept => "json", "User-Agent" => user_agent)
+      opts = HTTP::Options.new(:headers => {:accept => 'json'})
+      expect(opts.headers).to eq([%w[Accept json]])
     end
 
     it 'coerces :proxy correctly' do
-      opts = HTTP::Options.new(:proxy => {:proxy_address => "127.0.0.1", :proxy_port => 8080})
-      expect(opts.proxy).to eq(:proxy_address => "127.0.0.1", :proxy_port => 8080)
+      opts = HTTP::Options.new(:proxy => {:proxy_address => '127.0.0.1', :proxy_port => 8080})
+      expect(opts.proxy).to eq(:proxy_address => '127.0.0.1', :proxy_port => 8080)
     end
 
     it 'coerces :form correctly' do
       opts = HTTP::Options.new(:form => {:foo => 42})
       expect(opts.form).to eq(:foo => 42)
     end
-
-    it 'coerces :callbacks correctly' do
-      before, after = Proc.new{|r| :before}, Proc.new{|r| :after}
-      callbacks = {:request => [before], :response => [after]}
-      opts = HTTP::Options.new(:callbacks => callbacks)
-      expect(opts.callbacks).to eq({
-        :request  => [before],
-        :response => [after]
-      })
-    end
-
   end
-
 end

data/spec/http/options/proxy_spec.rb

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
-describe HTTP::Options, "proxy" do
+describe HTTP::Options, 'proxy' do
 
-  let(:opts){ HTTP::Options.new }
+  let(:opts) { HTTP::Options.new }
 
   it 'defaults to {}' do
     expect(opts.proxy).to eq({})
   end
 
   it 'may be specified with with_proxy' do
-    opts2 = opts.with_proxy(:proxy_address => "127.0.0.1", :proxy_port => 8080)
+    opts2 = opts.with_proxy(:proxy_address => '127.0.0.1', :proxy_port => 8080)
     expect(opts.proxy).to eq({})
-    expect(opts2.proxy).to eq(:proxy_address => "127.0.0.1", :proxy_port => 8080)
+    expect(opts2.proxy).to eq(:proxy_address => '127.0.0.1', :proxy_port => 8080)
   end
 
   it 'accepts proxy address, port, username, and password' do
-    opts2 = opts.with_proxy(:proxy_address => "127.0.0.1", :proxy_port => 8080, :proxy_username => "username", :proxy_password => "password")
-    expect(opts2.proxy).to eq(:proxy_address => "127.0.0.1", :proxy_port => 8080, :proxy_username => "username", :proxy_password => "password")
+    opts2 = opts.with_proxy(:proxy_address => '127.0.0.1', :proxy_port => 8080, :proxy_username => 'username', :proxy_password => 'password')
+    expect(opts2.proxy).to eq(:proxy_address => '127.0.0.1', :proxy_port => 8080, :proxy_username => 'username', :proxy_password => 'password')
   end
 end

data/spec/http/options_spec.rb

@@ -3,18 +3,12 @@ require 'spec_helper'
 describe HTTP::Options do
   subject { described_class.new(:response => :body) }
 
-  it "behaves like a Hash for reading" do
+  it 'behaves like a Hash for reading' do
     expect(subject[:response]).to eq(:body)
-    expect(subject[:nosuchone]).to be_nil
+    expect(subject[:nosuchone]).to be nil
   end
 
-  it "it's gois able to coerce to a Hash" do
+  it 'coerces to a Hash' do
     expect(subject.to_hash).to be_a(Hash)
-    expect(subject.to_hash[:response]).to eq(:body)
   end
-
-  it "raises ArgumentError with invalid options" do
-    expect { subject.with_response(:notrecognized) }.to raise_exception(ArgumentError)
-  end
-
 end

data/spec/http/redirector_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe HTTP::Redirector do
+  def simple_response(status, body = '', headers = {})
+    HTTP::Response.new(status, '1.1', headers, body)
+  end
+
+  def redirect_response(location, status)
+    simple_response status, '', 'Location' => location
+  end
+
+  let(:max_hops) { 5 }
+  subject(:redirector) { described_class.new max_hops }
+
+  context 'following 300 redirect' do
+    let(:orig_request)  { HTTP::Request.new :post, 'http://www.example.com/' }
+    let(:orig_response) { redirect_response 'http://example.com/', 300 }
+
+    it 'follows without changing verb' do
+      redirector.perform(orig_request, orig_response) do |request|
+        expect(request.verb).to be orig_request.verb
+        simple_response 200
+      end
+    end
+  end
+
+  context 'following 301 redirect' do
+    let(:orig_request)  { HTTP::Request.new :post, 'http://www.example.com/' }
+    let(:orig_response) { redirect_response 'http://example.com/', 301 }
+
+    it 'follows without changing verb' do
+      redirector.perform(orig_request, orig_response) do |request|
+        expect(request.verb).to be orig_request.verb
+        simple_response 200
+      end
+    end
+  end
+
+  context 'following 302 redirect' do
+    let(:orig_request)  { HTTP::Request.new :post, 'http://www.example.com/' }
+    let(:orig_response) { redirect_response 'http://example.com/', 302 }
+
+    it 'follows without changing verb' do
+      redirector.perform(orig_request, orig_response) do |request|
+        expect(request.verb).to be orig_request.verb
+        simple_response 200
+      end
+    end
+  end
+
+  context 'following 303 redirect' do
+    context 'upon POST request' do
+      let(:orig_request)  { HTTP::Request.new :post, 'http://www.example.com/' }
+      let(:orig_response) { redirect_response 'http://example.com/', 303 }
+
+      it 'follows without changing verb' do
+        redirector.perform(orig_request, orig_response) do |request|
+          expect(request.verb).to be :get
+          simple_response 200
+        end
+      end
+    end
+
+    context 'upon HEAD request' do
+      let(:orig_request)  { HTTP::Request.new :head, 'http://www.example.com/' }
+      let(:orig_response) { redirect_response 'http://example.com/', 303 }
+
+      it 'follows without changing verb' do
+        redirector.perform(orig_request, orig_response) do |request|
+          expect(request.verb).to be :get
+          simple_response 200
+        end
+      end
+    end
+  end
+
+  context 'following 307 redirect' do
+    let(:orig_request)  { HTTP::Request.new :post, 'http://www.example.com/' }
+    let(:orig_response) { redirect_response 'http://example.com/', 307 }
+
+    it 'follows without changing verb' do
+      redirector.perform(orig_request, orig_response) do |request|
+        expect(request.verb).to be orig_request.verb
+        simple_response 200
+      end
+    end
+  end
+
+  context 'following 308 redirect' do
+    let(:orig_request)  { HTTP::Request.new :post, 'http://www.example.com/' }
+    let(:orig_response) { redirect_response 'http://example.com/', 308 }
+
+    it 'follows without changing verb' do
+      redirector.perform(orig_request, orig_response) do |request|
+        expect(request.verb).to be orig_request.verb
+        simple_response 200
+      end
+    end
+  end
+end

data/spec/http/request/writer_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe HTTP::Request::Writer do
+  describe '#initalize' do
+    def construct(body)
+      HTTP::Request::Writer.new(nil, body, [], '')
+    end
+
+    it "doesn't throw on a nil body" do
+      expect { construct [] }.not_to raise_error
+    end
+
+    it "doesn't throw on a String body" do
+      expect { construct 'string body' }.not_to raise_error
+    end
+
+    it "doesn't throw on an Enumerable body" do
+      expect { construct %w[bees cows] }.not_to raise_error
+    end
+
+    it "does throw on a body that isn't string, enumerable or nil" do
+      expect { construct true }.to raise_error
+    end
+  end
+end

data/spec/http/request_spec.rb

@@ -1,19 +1,44 @@
 require 'spec_helper'
 
 describe HTTP::Request do
-  describe "headers" do
-    subject { HTTP::Request.new(:get, "http://example.com/", :accept => "text/html") }
+  it 'includes HTTP::Headers::Mixin' do
+    expect(described_class).to include HTTP::Headers::Mixin
+  end
+
+  it 'requires URI to have scheme part' do
+    expect { HTTP::Request.new(:get, 'example.com/') }.to \
+      raise_error(HTTP::Request::UnsupportedSchemeError)
+  end
+
+  it 'provides a #scheme accessor' do
+    request = HTTP::Request.new(:get, 'http://example.com/')
+    expect(request.scheme).to eq(:http)
+  end
 
-    it "sets explicit headers" do
-      expect(subject["Accept"]).to eq("text/html")
+  describe 'headers' do
+    subject { HTTP::Request.new(:get, 'http://example.com/', :accept => 'text/html') }
+
+    it 'sets explicit headers' do
+      expect(subject['Accept']).to eq('text/html')
+    end
+
+    it 'sets implicit headers' do
+      expect(subject['Host']).to eq('example.com')
     end
 
-    it "sets implicit headers" do
-      expect(subject["Host"]).to eq("example.com")
+    it 'provides a #verb accessor' do
+      expect(subject.verb).to eq(:get)
     end
 
-    it "provides a #headers accessor" do
-      expect(subject.headers).to eq("Accept" => "text/html", "Host" => "example.com")
+    it 'provides a #method accessor that outputs a deprecation warning and returns the verb' do
+      warning = capture_warning do
+        expect(subject.method).to eq(subject.verb)
+      end
+      expect(warning).to match(/\[DEPRECATION\] HTTP::Request#method is deprecated\. Use #verb instead\. For Object#method, use #__method__\.$/)
+    end
+
+    it 'provides a #__method__ method that delegates to Object#method' do
+      expect(subject.__method__(:verb)).to be_a(Method)
     end
   end
 
@@ -27,12 +52,12 @@ describe HTTP::Request do
 
     its(:uri)     { should eq URI.parse 'http://blog.example.com/' }
 
-    its(:method)  { should eq request.method }
+    its(:verb)    { should eq request.verb }
     its(:body)    { should eq request.body }
     its(:proxy)   { should eq request.proxy }
 
     it 'presets new Host header' do
-      expect(redirected.headers['Host']).to eq 'blog.example.com'
+      expect(redirected['Host']).to eq 'blog.example.com'
     end
 
     context 'with relative URL given' do
@@ -40,12 +65,17 @@ describe HTTP::Request do
 
       its(:uri)     { should eq URI.parse 'http://example.com/blog' }
 
-      its(:method)  { should eq request.method }
+      its(:verb)    { should eq request.verb }
       its(:body)    { should eq request.body }
       its(:proxy)   { should eq request.proxy }
 
       it 'keeps Host header' do
-        expect(redirected.headers['Host']).to eq 'example.com'
+        expect(redirected['Host']).to eq 'example.com'
+      end
+
+      context 'with original URI having non-standard port' do
+        let(:request) { HTTP::Request.new(:post, 'http://example.com:8080/', headers, proxy, body) }
+        its(:uri)     { should eq URI.parse 'http://example.com:8080/blog' }
       end
     end
 
@@ -54,13 +84,23 @@ describe HTTP::Request do
 
       its(:uri)     { should eq URI.parse 'http://example.com/blog' }
 
-      its(:method)  { should eq request.method }
+      its(:verb)    { should eq request.verb }
       its(:body)    { should eq request.body }
       its(:proxy)   { should eq request.proxy }
 
       it 'keeps Host header' do
-        expect(redirected.headers['Host']).to eq 'example.com'
+        expect(redirected['Host']).to eq 'example.com'
       end
+
+      context 'with original URI having non-standard port' do
+        let(:request) { HTTP::Request.new(:post, 'http://example.com:8080/', headers, proxy, body) }
+        its(:uri)     { should eq URI.parse 'http://example.com:8080/blog' }
+      end
+    end
+
+    context 'with new verb given' do
+      subject { request.redirect 'http://blog.example.com/', :get }
+      its(:verb) { should be :get }
     end
   end
 end