http 0.5.1 → 0.6.0.pre

data/spec/http/response/body_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe HTTP::Response::Body do
+  let(:body)     { 'Hello, world!' }
+  let(:response) { double(:response) }
+
+  subject { described_class.new(response) }
+
+  before do
+    response.should_receive(:readpartial).and_return(body)
+    response.should_receive(:readpartial).and_return(nil)
+  end
+
+  it 'streams bodies from responses' do
+    expect(subject.to_s).to eq body
+  end
+
+  context 'when body empty' do
+    let(:body) { '' }
+    it 'returns responds to empty? with true' do
+      expect(subject).to be_empty
+    end
+  end
+end

data/spec/http/response_spec.rb

@@ -1,56 +1,85 @@
 require 'spec_helper'
 
 describe HTTP::Response do
-  describe "headers" do
-    subject { HTTP::Response.new(200, "1.1", "Content-Type" => "text/plain") }
+  it 'includes HTTP::Headers::Mixin' do
+    expect(described_class).to include HTTP::Headers::Mixin
+  end
+
+  describe 'to_a' do
+    let(:body)         { 'Hello world' }
+    let(:content_type) { 'text/plain' }
+    subject { HTTP::Response.new(200, '1.1', {'Content-Type' => content_type}, body) }
+
+    it 'returns a Rack-like array' do
+      expect(subject.to_a).to eq([200, {'Content-Type' => content_type}, body])
+    end
+  end
+
+  describe 'mime_type' do
+    subject { HTTP::Response.new(200, '1.1', headers, '').mime_type }
+
+    context 'without Content-Type header' do
+      let(:headers) { {} }
+      it { should be_nil }
+    end
 
-    it "exposes header fields for easy access" do
-      expect(subject["Content-Type"]).to eq("text/plain")
+    context 'with Content-Type: text/html' do
+      let(:headers) { {'Content-Type' => 'text/html'} }
+      it { should eq 'text/html' }
     end
 
-    it "provides a #headers accessor too" do
-      expect(subject.headers).to eq("Content-Type" => "text/plain")
+    context 'with Content-Type: text/html; charset=utf-8' do
+      let(:headers) { {'Content-Type' => 'text/html; charset=utf-8'} }
+      it { should eq 'text/html' }
     end
   end
 
-  describe "#parse_body" do
-    context "on a registered MIME type" do
-      let(:body) { ::JSON.dump("Hello" => "World") }
-      subject { HTTP::Response.new(200, "1.1", {"Content-Type" => "application/json"}, body) }
+  describe 'charset' do
+    subject { HTTP::Response.new(200, '1.1', headers, '').charset }
 
-      it "returns a parsed response body" do
-        expect(subject.parse_body).to eq ::JSON.parse(body)
-      end
+    context 'without Content-Type header' do
+      let(:headers) { {} }
+      it { should be_nil }
     end
 
-    context "on an unregistered MIME type" do
-      let(:body) { "Hello world" }
-      subject { HTTP::Response.new(200, "1.1", {"Content-Type" => "text/plain"}, body) }
+    context 'with Content-Type: text/html' do
+      let(:headers) { {'Content-Type' => 'text/html'} }
+      it { should be_nil }
+    end
 
-      it "returns the raw body as a String" do
-        expect(subject.parse_body).to eq(body)
-      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' }
     end
   end
 
-  describe "to_a" do
-    context "on a registered MIME type" do
-      let(:body) { ::JSON.dump("Hello" => "World") }
-      let(:content_type) { "application/json" }
-      subject { HTTP::Response.new(200, "1.1", {"Content-Type" => content_type}, body) }
+  describe '#parse' do
+    let(:headers)   { {'Content-Type' => content_type} }
+    let(:body)      { '{"foo":"bar"}' }
+    let(:response)  { HTTP::Response.new 200, '1.1', headers, body }
 
-      it "retuns a Rack-like array with a parsed response body" do
-        expect(subject.to_a).to eq([200, {"Content-Type" => content_type}, ::JSON.parse(body)])
+    context 'with known content type' do
+      let(:content_type) { 'application/json' }
+      it 'returns parsed body' do
+        expect(response.parse).to eq 'foo' => 'bar'
       end
     end
 
-    context "on an unregistered MIME type" do
-      let(:body)         { "Hello world" }
-      let(:content_type) { "text/plain" }
-      subject { HTTP::Response.new(200, "1.1", {"Content-Type" => content_type}, body) }
+    context 'with unknown content type' do
+      let(:content_type) { 'application/deadbeef' }
+      it 'raises HTTP::Error' do
+        expect { response.parse }.to raise_error HTTP::Error
+      end
+    end
+
+    context 'with explicitly given mime type' do
+      let(:content_type) { 'application/deadbeef' }
+      it 'ignores mime_type of response' do
+        expect(response.parse 'application/json').to eq 'foo' => 'bar'
+      end
 
-      it "returns a Rack-like array" do
-        expect(subject.to_a).to eq([200, {"Content-Type" => content_type}, body])
+      it 'supports MIME type aliases' do
+        expect(response.parse :json).to eq 'foo' => 'bar'
       end
     end
   end

data/spec/http_spec.rb

@@ -3,143 +3,134 @@ require 'json'
 
 describe HTTP do
   let(:test_endpoint)  { "http://127.0.0.1:#{ExampleService::PORT}/" }
-  let(:proxy_endpoint) { "#{test_endpoint}proxy" }
 
-  context "getting resources" do
-    it "should be easy" do
+  context 'getting resources' do
+    it 'should be easy' do
       response = HTTP.get test_endpoint
-      expect(response).to match(/<!doctype html>/)
+      expect(response.to_s).to match(/<!doctype html>/)
     end
 
-    it "should be easy to get a response object" do
-      response = HTTP.get(test_endpoint).response
-      expect(response).to be_a HTTP::Response
-    end
-
-    context "with_response" do
-      it 'allows specifying :object' do
-        res = HTTP.with_response(:object).get test_endpoint
-        expect(res).to be_a(HTTP::Response)
+    context 'with URI instance' do
+      it 'should be 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 "should be easy" do
+    context 'with query string parameters' do
+      it 'should be easy' do
         response = HTTP.get "#{test_endpoint}params" , :params => {:foo => 'bar'}
-        expect(response).to  match(/Params!/)
+        expect(response.to_s).to match(/Params!/)
       end
     end
 
-    context "with headers" do
-      it "should be easy" do
-        response = HTTP.accept(:json).get test_endpoint
-        expect(response['json']).to be_true
+    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'}
+        expect(response.to_s).to match(/More Params!/)
       end
     end
 
-    context "with callbacks" do
-      it "fires a request callback" do
-        pending 'HTTP::Request is not yet implemented'
-
-        request = nil
-        HTTP.on(:request) {|r| request = r}.get test_endpoint
-        expect(request).to be_a HTTP::Request
-      end
-
-      it "fires a response callback" do
-        response = nil
-        HTTP.on(:response) {|r| response = r}.get test_endpoint
-        expect(response).to be_a HTTP::Response
+    context 'with headers' do
+      it 'should be easy' do
+        response = HTTP.accept('application/json').get test_endpoint
+        expect(response.to_s.include?('json')).to be true
       end
     end
+  end
 
-    it "should not mess with the returned status" do
-      client = HTTP.with_response(:object)
-      res = client.get test_endpoint
-      expect(res.status).to eq(200)
-      res = client.get "#{test_endpoint}not-found"
-      expect(res.status).to eq(404)
+  context 'with http proxy address and port' do
+    it 'should proxy 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 and port" do
-    it "should proxy the request" do
-      response = HTTP.via("127.0.0.1", 8080).get proxy_endpoint
-      expect(response).to match(/Proxy!/)
+  context 'with http proxy address, port username and password' do
+    it 'should proxy 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
-  end
 
-  context "with http proxy address, port username and password" do
-    it "should proxy the request" do
-      response = HTTP.via("127.0.0.1", 8081, "username", "password").get proxy_endpoint
-      expect(response).to match(/Proxy!/)
+    it 'responds with the endpoint\'s body' do
+      response = HTTP.via('127.0.0.1', 8081, 'username', 'password').get test_endpoint
+      expect(response.to_s).to match(/<!doctype html>/)
     end
   end
 
-  context "with http proxy address, port, with wrong username and password" do
-    it "should proxy the request" do
-      pending "fixing proxy support"
-
-      response = HTTP.via("127.0.0.1", 8081, "user", "pass").get proxy_endpoint
-      expect(response).to match(/Proxy Authentication Required/)
+  context 'with http proxy address, port, with wrong username and password' do
+    it 'responds with 407' do
+      response = HTTP.via('127.0.0.1', 8081, 'user', 'pass').get test_endpoint
+      expect(response.status).to eq(407)
     end
   end
 
-  context "without proxy port" do
-    it "should raise an argument error" do
-      expect { HTTP.via("127.0.0.1") }.to raise_error ArgumentError
+  context 'without proxy port' do
+    it 'should raise 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
+  context 'posting to resources' do
+    it 'should be easy to post forms' do
       response = HTTP.post "#{test_endpoint}form", :form => {:example => 'testing-form'}
-      expect(response).to eq("passed :)")
+      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"
-      expect(response).to eq("passed :)")
+  context 'posting with an explicit body' do
+    it 'should be easy to post' 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
+  context 'with redirects' do
+    it 'should be easy for 301' do
       response = HTTP.with_follow(true).get("#{test_endpoint}redirect-301")
-      expect(response).to match(/<!doctype html>/)
+      expect(response.to_s).to match(/<!doctype html>/)
     end
 
-    it "should be easy for 302" do
+    it 'should be easy for 302' do
       response = HTTP.with_follow(true).get("#{test_endpoint}redirect-302")
-      expect(response).to match(/<!doctype html>/)
-    end
-
-    it "should include previous host" do
-      response = HTTP.with_follow(true).get("#{test_endpoint}relative-redirect-302")
-      expect(response).to match(/<!doctype html>/)
-    end
-
-    it "should parse redirects with params" do
-      response = HTTP.with_follow(true).get("#{test_endpoint}relative-redirect-with-params-302")
-      expect(response).to match(/Params!/)
+      expect(response.to_s).to match(/<!doctype html>/)
     end
 
   end
 
-  context "head requests" do
-    it "should be easy" do
+  context 'head requests' do
+    it 'should be easy' do
       response = HTTP.head test_endpoint
       expect(response.status).to eq(200)
       expect(response['content-type']).to match(/html/)
     end
   end
 
-  it "should be chainable" do
-    response = HTTP.accept(:json).on(:response){|r| r}.get(test_endpoint)
-    expect(response['json']).to be_true
-  end
+  describe '.auth' do
+    context 'with no arguments' do
+      specify { expect { HTTP.auth }.to raise_error }
+    end
+
+    context 'with one argument' do
+      it 'returns branch with Authorization header as is' do
+        expect(HTTP).to receive(:with) \
+          .with :authorization => 'foobar'
+
+        HTTP.auth :foobar
+      end
+    end
 
+    context 'with two arguments' do
+      it 'builds value with AuthorizationHeader builder' do
+        expect(HTTP::AuthorizationHeader).to receive(:build) \
+          .with(:bearer, :token => 'token')
+
+        HTTP.auth :bearer, :token => 'token'
+      end
+    end
+
+    context 'with more than two arguments' do
+      specify { expect { HTTP.auth 1, 2, 3 }.to raise_error }
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,11 +1,34 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start do
+  add_filter '/spec/'
+  minimum_coverage(80)
+end
+
 require 'http'
 require 'support/example_server'
 require 'support/proxy_server'
-require 'coveralls'
-Coveralls.wear!
 
 RSpec.configure do |config|
   config.expect_with :rspec do |c|
     c.syntax = :expect
   end
 end
+
+def capture_warning
+  begin
+    old_stderr = $stderr
+    $stderr = StringIO.new
+    yield
+    result = $stderr.string
+  ensure
+    $stderr = old_stderr
+  end
+  result
+end

data/spec/support/example_server.rb

@@ -1,78 +1,86 @@
 require 'webrick'
 
 class ExampleService < WEBrick::HTTPServlet::AbstractServlet
-  PORT = 65432
-
-  def do_GET(request, response)
+  PORT = 65432 # rubocop:disable NumericLiterals
 
+  def do_GET(request, response) # rubocop:disable MethodName
     case request.path
-    when "/"
-      response.status = 200
-
-      case request['Accept']
-      when 'application/json'
-        response['Content-Type'] = 'application/json'
-        response.body = '{"json": true}'
-      else
-        response['Content-Type'] = 'text/html'
-        response.body   = "<!doctype html>"
-      end
-    when "/params"
-      if request.query_string="foo=bar"
-        response.status = 200
-        response.body     = "Params!"
-      end
-    when "/proxy"
+    when '/'
+      handle_root(request, response)
+    when '/params'
+      handle_params(request, response)
+    when '/multiple-params'
+      handle_multiple_params(request, response)
+    when '/proxy'
       response.status = 200
-      response.body     = "Proxy!"
-    when "/not-found"
-      response.body   = "not found"
+      response.body     = 'Proxy!'
+    when '/not-found'
+      response.body   = 'not found'
       response.status = 404
-    when "/redirect-301"
+    when '/redirect-301'
       response.status = 301
-      response["Location"] = "http://127.0.0.1:#{PORT}/"
-    when "/redirect-302"
+      response['Location'] = "http://127.0.0.1:#{PORT}/"
+    when '/redirect-302'
       response.status = 302
-      response["Location"] = "http://127.0.0.1:#{PORT}/"
-    when "/relative-redirect-302"
-      response.request_uri = nil
-      response.status = 302
-      response["Location"] = "/"
-    when "/relative-redirect-with-params-302"
-      response.request_uri = nil
-      response.status = 302
-      response["Location"] = "/params?foo=bar"
+      response['Location'] = "http://127.0.0.1:#{PORT}/"
     else
       response.status = 404
     end
   end
 
-  def do_POST(request, response)
+  def handle_root(request, response)
+    response.status = 200
+    case request['Accept']
+    when 'application/json'
+      response['Content-Type'] = 'application/json'
+      response.body = '{"json": true}'
+    else
+      response['Content-Type'] = 'text/html'
+      response.body   = '<!doctype html>'
+    end
+  end
+
+  def handle_params(request, response)
+    if request.query_string == 'foo=bar'
+      response.status = 200
+      response.body     = 'Params!'
+    end
+  end
+
+  def handle_multiple_params(request, response)
+    params = CGI.parse(request.query_string)
+    if params == {'foo' => ['bar'], 'baz' => ['quux']}
+      response.status = 200
+      response.body     = 'More Params!'
+    end
+  end
+
+  def do_POST(request, response) # rubocop:disable MethodName
     case request.path
-    when "/form"
+    when '/form'
       if request.query['example'] == 'testing-form'
         response.status = 200
-        response.body   = "passed :)"
+        response.body   = 'passed :)'
       else
         response.status = 400
-        response.body   = "invalid! >:E"
+        response.body   = 'invalid! >:E'
       end
-    when "/body"
+    when '/body'
       if request.body == 'testing-body'
         response.status = 200
-        response.body   = "passed :)"
+        response.body   = 'passed :)'
       else
         response.status = 400
-        response.body   = "invalid! >:E"
+        response.body   = 'invalid! >:E'
       end
     else
       response.status = 404
     end
   end
 
-  def do_HEAD(request, response)
+  def do_HEAD(request, response) # rubocop:disable MethodName
     case request.path
-    when "/"
+    when '/'
       response.status = 200
       response['Content-Type'] = 'text/html'
     else
@@ -82,11 +90,12 @@ class ExampleService < WEBrick::HTTPServlet::AbstractServlet
 end
 
 ExampleServer = WEBrick::HTTPServer.new(:Port => ExampleService::PORT, :AccessLog => [])
-ExampleServer.mount "/", ExampleService
+ExampleServer.mount '/', ExampleService
 
 t = Thread.new { ExampleServer.start }
-trap("INT")    { ExampleServer.shutdown; exit }
-
-Thread.pass while t.status and t.status != "sleep"
-
+trap('INT') do
+  ExampleServer.shutdown
+  exit
+end
 
+Thread.pass while t.status && t.status != 'sleep'