http 0.6.4 → 0.7.0

data/spec/http/request_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe HTTP::Request do
+RSpec.describe HTTP::Request do
   let(:headers)     { {:accept => 'text/html'} }
   let(:request_uri) { 'http://example.com/' }
 
@@ -19,6 +19,17 @@ describe HTTP::Request do
     expect(request.scheme).to eq(:http)
   end
 
+  it 'provides a #verb accessor' do
+    expect(subject.verb).to eq(:get)
+  end
+
+  it 'provides a #__method__ method that outputs a deprecation warning and delegates to Object#method' do
+    warning = capture_warning do
+      expect(subject.__method__(:verb)).to eq(subject.method(:verb))
+    end
+    expect(warning).to match(/\[DEPRECATION\] HTTP::Request#__method__ is deprecated\. Use #method instead\.$/)
+  end
+
   it 'sets given headers' do
     expect(subject['Accept']).to eq('text/html')
   end
@@ -54,21 +65,6 @@ describe HTTP::Request do
     end
   end
 
-  it 'provides a #verb accessor' do
-    expect(subject.verb).to eq(:get)
-  end
-
-  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
-
   describe '#redirect' do
     let(:headers)   { {:accept => 'text/html'} }
     let(:proxy)     { {:proxy_username => 'douglas', :proxy_password => 'adams'} }
@@ -77,11 +73,11 @@ describe HTTP::Request do
 
     subject(:redirected) { request.redirect 'http://blog.example.com/' }
 
-    its(:uri)     { should eq URI.parse 'http://blog.example.com/' }
+    its(:uri)     { is_expected.to eq URI.parse 'http://blog.example.com/' }
 
-    its(:verb)    { should eq request.verb }
-    its(:body)    { should eq request.body }
-    its(:proxy)   { should eq request.proxy }
+    its(:verb)    { is_expected.to eq request.verb }
+    its(:body)    { is_expected.to eq request.body }
+    its(:proxy)   { is_expected.to eq request.proxy }
 
     it 'presets new Host header' do
       expect(redirected['Host']).to eq 'blog.example.com'
@@ -90,11 +86,11 @@ describe HTTP::Request do
     context 'with schema-less absolute URL given' do
       subject(:redirected) { request.redirect '//another.example.com/blog' }
 
-      its(:uri)     { should eq URI.parse 'http://another.example.com/blog' }
+      its(:uri)     { is_expected.to eq URI.parse 'http://another.example.com/blog' }
 
-      its(:verb)    { should eq request.verb }
-      its(:body)    { should eq request.body }
-      its(:proxy)   { should eq request.proxy }
+      its(:verb)    { is_expected.to eq request.verb }
+      its(:body)    { is_expected.to eq request.body }
+      its(:proxy)   { is_expected.to eq request.proxy }
 
       it 'presets new Host header' do
         expect(redirected['Host']).to eq 'another.example.com'
@@ -104,11 +100,11 @@ describe HTTP::Request do
     context 'with relative URL given' do
       subject(:redirected) { request.redirect '/blog' }
 
-      its(:uri)     { should eq URI.parse 'http://example.com/blog' }
+      its(:uri)     { is_expected.to eq URI.parse 'http://example.com/blog' }
 
-      its(:verb)    { should eq request.verb }
-      its(:body)    { should eq request.body }
-      its(:proxy)   { should eq request.proxy }
+      its(:verb)    { is_expected.to eq request.verb }
+      its(:body)    { is_expected.to eq request.body }
+      its(:proxy)   { is_expected.to eq request.proxy }
 
       it 'keeps Host header' do
         expect(redirected['Host']).to eq 'example.com'
@@ -116,18 +112,18 @@ describe HTTP::Request do
 
       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' }
+        its(:uri)     { is_expected.to eq URI.parse 'http://example.com:8080/blog' }
       end
     end
 
     context 'with relative URL that misses leading slash given' do
       subject(:redirected) { request.redirect 'blog' }
 
-      its(:uri)     { should eq URI.parse 'http://example.com/blog' }
+      its(:uri)     { is_expected.to eq URI.parse 'http://example.com/blog' }
 
-      its(:verb)    { should eq request.verb }
-      its(:body)    { should eq request.body }
-      its(:proxy)   { should eq request.proxy }
+      its(:verb)    { is_expected.to eq request.verb }
+      its(:body)    { is_expected.to eq request.body }
+      its(:proxy)   { is_expected.to eq request.proxy }
 
       it 'keeps Host header' do
         expect(redirected['Host']).to eq 'example.com'
@@ -135,13 +131,13 @@ describe HTTP::Request do
 
       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' }
+        its(:uri)     { is_expected.to 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 }
+      its(:verb) { is_expected.to be :get }
     end
   end
 end

data/spec/http/response/body_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe HTTP::Response::Body do
+RSpec.describe HTTP::Response::Body do
   let(:client)   { double }
   let(:chunks)   { ['Hello, ', 'World!'] }
 

data/spec/http/response/status_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+RSpec.describe HTTP::Response::Status do
+  describe '.new' do
+    it 'fails if given value does not respond to #to_i' do
+      expect { described_class.new double }.to raise_error
+    end
+
+    it 'accepts any object that responds to #to_i' do
+      expect { described_class.new double :to_i => 200 }.to_not raise_error
+    end
+  end
+
+  describe '#code' do
+    subject { described_class.new('200.0').code }
+    it { is_expected.to eq 200 }
+    it { is_expected.to be_a Fixnum }
+  end
+
+  describe '#reason' do
+    subject { described_class.new(code).reason }
+
+    context 'with unknown code' do
+      let(:code) { 1024 }
+      it { is_expected.to be_nil }
+    end
+
+    described_class::REASONS.each do |code, reason|
+      class_eval <<-RUBY
+        context 'with well-known code: #{code}' do
+          let(:code) { #{code} }
+          it { is_expected.to eq #{reason.inspect} }
+          it { is_expected.to be_frozen }
+        end
+      RUBY
+    end
+  end
+
+  describe '#symbolize' do
+    subject { described_class.new(code).symbolize }
+
+    context 'with unknown code' do
+      let(:code) { 1024 }
+      it { is_expected.to be_nil }
+    end
+
+    described_class::SYMBOLS.each do |code, symbol|
+      class_eval <<-RUBY
+        context 'with well-known code: #{code}' do
+          let(:code) { #{code} }
+          it { is_expected.to be #{symbol.inspect} }
+        end
+      RUBY
+    end
+  end
+
+  describe '#inspect' do
+    it 'returns quoted code and reason phrase' do
+      status = described_class.new 200
+      expect(status.inspect).to eq '"200 OK"'
+    end
+  end
+
+  # testing edge cases only
+  describe '::SYMBOLS' do
+    subject { described_class::SYMBOLS }
+
+    # "OK"
+    its([200]) { is_expected.to be :ok }
+
+    # "Bad Request"
+    its([400]) { is_expected.to be :bad_request }
+
+    # "Request-URI Too Long"
+    its([414]) { is_expected.to be :request_uri_too_long }
+
+    # "I'm a Teapot"
+    its([418]) { is_expected.to be :im_a_teapot }
+  end
+
+  described_class::SYMBOLS.each do |code, symbol|
+    class_eval <<-RUBY
+      describe '##{symbol}?' do
+        subject { status.#{symbol}? }
+
+        context 'when code is #{code}' do
+          let(:status) { described_class.new #{code} }
+          it { is_expected.to be true }
+        end
+
+        context 'when code is higher than #{code}' do
+          let(:status) { described_class.new #{code + 1} }
+          it { is_expected.to be false }
+        end
+
+        context 'when code is lower than #{code}' do
+          let(:status) { described_class.new #{code - 1} }
+          it { is_expected.to be false }
+        end
+      end
+    RUBY
+  end
+
+  describe '.coerce' do
+    context 'with String' do
+      it 'coerces reasons' do
+        expect(described_class.coerce 'Bad request').to eq described_class.new 400
+      end
+
+      it 'fails when reason is unknown' do
+        expect { described_class.coerce 'foobar' }.to raise_error HTTP::Error
+      end
+    end
+
+    context 'with Symbol' do
+      it 'coerces symbolized reasons' do
+        expect(described_class.coerce :bad_request).to eq described_class.new 400
+      end
+
+      it 'fails when symbolized reason is unknown' do
+        expect { described_class.coerce :foobar }.to raise_error HTTP::Error
+      end
+    end
+
+    context 'with Numeric' do
+      it 'coerces as Fixnum code' do
+        expect(described_class.coerce 200.1).to eq described_class.new 200
+      end
+    end
+
+    it 'fails if coercion failed' do
+      expect { described_class.coerce true }.to raise_error HTTP::Error
+    end
+
+    it 'is aliased as `.[]`' do
+      expect(described_class.method :coerce).to eq described_class.method :[]
+    end
+  end
+end

data/spec/http/response_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe HTTP::Response do
+RSpec.describe HTTP::Response do
   it 'includes HTTP::Headers::Mixin' do
     expect(described_class).to include HTTP::Headers::Mixin
   end
@@ -20,17 +20,17 @@ describe HTTP::Response do
 
     context 'without Content-Type header' do
       let(:headers) { {} }
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
 
     context 'with Content-Type: text/html' do
       let(:headers) { {'Content-Type' => 'text/html'} }
-      it { should eq 'text/html' }
+      it { is_expected.to eq 'text/html' }
     end
 
     context 'with Content-Type: text/html; charset=utf-8' do
       let(:headers) { {'Content-Type' => 'text/html; charset=utf-8'} }
-      it { should eq 'text/html' }
+      it { is_expected.to eq 'text/html' }
     end
   end
 
@@ -39,17 +39,17 @@ describe HTTP::Response do
 
     context 'without Content-Type header' do
       let(:headers) { {} }
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
 
     context 'with Content-Type: text/html' do
       let(:headers) { {'Content-Type' => 'text/html'} }
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
 
     context 'with Content-Type: text/html; charset=utf-8' do
       let(:headers) { {'Content-Type' => 'text/html; charset=utf-8'} }
-      it { should eq 'utf-8' }
+      it { is_expected.to eq 'utf-8' }
     end
   end
 

data/spec/http_spec.rb

@@ -1,38 +1,38 @@
 require 'spec_helper'
 require 'json'
 
-describe HTTP do
-  let(:test_endpoint)  { "http://127.0.0.1:#{ExampleService::PORT}/" }
+RSpec.describe HTTP do
+  let(:test_endpoint)  { "http://#{ExampleServer::ADDR}" }
 
   context 'getting resources' do
-    it 'should be easy' do
+    it 'is easy' do
       response = HTTP.get test_endpoint
       expect(response.to_s).to match(/<!doctype html>/)
     end
 
     context 'with URI instance' do
-      it 'should be easy' do
-        response = HTTP.get URI(test_endpoint)
+      it 'is easy' do
+        response = HTTP.get URI test_endpoint
         expect(response.to_s).to match(/<!doctype html>/)
       end
     end
 
     context 'with query string parameters' do
       it 'is easy' do
-        response = HTTP.get "#{test_endpoint}params", :params => {:foo => 'bar'}
+        response = HTTP.get "#{test_endpoint}/params", :params => {:foo => 'bar'}
         expect(response.to_s).to match(/Params!/)
       end
     end
 
     context 'with query string parameters in the URI and opts hash' do
       it 'includes both' do
-        response = HTTP.get "#{test_endpoint}multiple-params?foo=bar", :params => {:baz => 'quux'}
+        response = HTTP.get "#{test_endpoint}/multiple-params?foo=bar", :params => {:baz => 'quux'}
         expect(response.to_s).to match(/More Params!/)
       end
     end
 
     context 'with headers' do
-      it 'should be easy' do
+      it 'is easy' do
         response = HTTP.accept('application/json').get test_endpoint
         expect(response.to_s.include?('json')).to be true
       end
@@ -40,14 +40,14 @@ describe HTTP do
   end
 
   context 'with http proxy address and port' do
-    it 'should proxy the request' do
+    it 'proxies the request' do
       response = HTTP.via('127.0.0.1', 8080).get test_endpoint
       expect(response.headers['X-Proxied']).to eq 'true'
     end
   end
 
   context 'with http proxy address, port username and password' do
-    it 'should proxy the request' do
+    it 'proxies the request' do
       response = HTTP.via('127.0.0.1', 8081, 'username', 'password').get test_endpoint
       expect(response.headers['X-Proxied']).to eq 'true'
     end
@@ -66,40 +66,40 @@ describe HTTP do
   end
 
   context 'without proxy port' do
-    it 'should raise an argument error' do
+    it 'raises an argument error' do
       expect { HTTP.via('127.0.0.1') }.to raise_error HTTP::RequestError
     end
   end
 
-  context 'posting to resources' do
-    it 'should be easy to post forms' do
-      response = HTTP.post "#{test_endpoint}form", :form => {:example => 'testing-form'}
+  context 'posting forms to resources' do
+    it 'is easy' do
+      response = HTTP.post "#{test_endpoint}/form", :form => {:example => 'testing-form'}
       expect(response.to_s).to eq('passed :)')
     end
   end
 
   context 'posting with an explicit body' do
-    it 'should be easy to post' do
-      response = HTTP.post "#{test_endpoint}body", :body => 'testing-body'
+    it 'is easy' do
+      response = HTTP.post "#{test_endpoint}/body", :body => 'testing-body'
       expect(response.to_s).to eq('passed :)')
     end
   end
 
   context 'with redirects' do
-    it 'should be easy for 301' do
-      response = HTTP.with_follow(true).get("#{test_endpoint}redirect-301")
+    it 'is easy for 301' do
+      response = HTTP.with_follow(true).get("#{test_endpoint}/redirect-301")
       expect(response.to_s).to match(/<!doctype html>/)
     end
 
-    it 'should be easy for 302' do
-      response = HTTP.with_follow(true).get("#{test_endpoint}redirect-302")
+    it 'is easy for 302' do
+      response = HTTP.with_follow(true).get("#{test_endpoint}/redirect-302")
       expect(response.to_s).to match(/<!doctype html>/)
     end
 
   end
 
   context 'head requests' do
-    it 'should be easy' do
+    it 'is easy' do
       response = HTTP.head test_endpoint
       expect(response.status).to eq(200)
       expect(response['content-type']).to match(/html/)
@@ -107,30 +107,34 @@ describe HTTP do
   end
 
   describe '.auth' do
-    context 'with no arguments' do
-      specify { expect { HTTP.auth }.to raise_error }
+    it 'sets Authorization header to the given value' do
+      client = HTTP.auth 'abc'
+      expect(client.default_headers[:authorization]).to eq 'abc'
     end
 
-    context 'with one argument' do
-      it 'returns branch with Authorization header as is' do
-        expect(HTTP).to receive(:with) \
-          .with :authorization => 'foobar'
+    it 'accepts any #to_s object' do
+      client = HTTP.auth double :to_s => 'abc'
+      expect(client.default_headers[:authorization]).to eq 'abc'
+    end
+  end
 
-        HTTP.auth :foobar
-      end
+  describe '.basic_auth' do
+    it 'fails when options is not a Hash' do
+      expect { HTTP.basic_auth '[FOOBAR]' }.to raise_error
     end
 
-    context 'with two arguments' do
-      it 'builds value with AuthorizationHeader builder' do
-        expect(HTTP::AuthorizationHeader).to receive(:build) \
-          .with(:bearer, :token => 'token')
+    it 'fails when :pass is not given' do
+      expect { HTTP.basic_auth :user => '[USER]' }.to raise_error
+    end
 
-        HTTP.auth :bearer, :token => 'token'
-      end
+    it 'fails when :user is not given' do
+      expect { HTTP.basic_auth :pass => '[PASS]' }.to raise_error
     end
 
-    context 'with more than two arguments' do
-      specify { expect { HTTP.auth 1, 2, 3 }.to raise_error }
+    it 'sets Authorization header with proper BasicAuth value' do
+      client = HTTP.basic_auth :user => 'foo', :pass => 'bar'
+      expect(client.default_headers[:authorization])
+        .to match(/^Basic [A-Za-z0-9+\/]+=*$/)
     end
   end
 end