http 0.7.4 → 0.8.0.pre

data/spec/lib/http/response/io_body_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe HTTP::Response::IoBody do
+  subject(:body) { described_class.new StringIO.new("Hello, World!") }
+
+  it "has the content" do
+    expect(subject.to_s).to eq "Hello, World!"
+  end
+
+  context "when body empty" do
+    subject(:body) { described_class.new StringIO.new("") }
+
+    it "returns responds to empty? with true" do
+      expect(subject).to be_empty
+    end
+  end
+
+  describe "#readpartial" do
+    context "with size given" do
+      it "returns only that amount" do
+        expect(body.readpartial(4)).to eq "Hell"
+      end
+    end
+
+    context "without size given" do
+      it "returns parts of the content" do
+        expect(body.readpartial).to eq "Hello, World!"
+      end
+    end
+  end
+
+  describe "#each" do
+    it "yields successive parts of the content" do
+      expect { |b| body.each(&b) }.to yield_with_args "Hello, World!"
+    end
+  end
+end

data/spec/lib/http/response/status_spec.rb

@@ -1,24 +1,24 @@
 RSpec.describe HTTP::Response::Status do
-  describe '.new' do
-    it 'fails if given value does not respond to #to_i' 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
+    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 }
+  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
+  describe "#reason" do
     subject { described_class.new(code).reason }
 
-    context 'with unknown code' do
+    context "with unknown code" do
       let(:code) { 1024 }
       it { is_expected.to be_nil }
     end
@@ -34,10 +34,10 @@ RSpec.describe HTTP::Response::Status do
     end
   end
 
-  describe '#symbolize' do
+  describe "#symbolize" do
     subject { described_class.new(code).symbolize }
 
-    context 'with unknown code' do
+    context "with unknown code" do
       let(:code) { 1024 }
       it { is_expected.to be_nil }
     end
@@ -52,15 +52,15 @@ RSpec.describe HTTP::Response::Status do
     end
   end
 
-  describe '#inspect' do
-    it 'returns quoted code and reason phrase' do
+  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
+  describe "::SYMBOLS" do
     subject { described_class::SYMBOLS }
 
     # "OK"
@@ -99,38 +99,38 @@ RSpec.describe HTTP::Response::Status do
     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
+  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
+      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
+    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
+      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
+    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
+    it "fails if coercion failed" do
       expect { described_class.coerce true }.to raise_error HTTP::Error
     end
 
-    it 'is aliased as `.[]`' do
+    it "is aliased as `.[]`" do
       expect(described_class.method :coerce).to eq described_class.method :[]
     end
   end

data/spec/lib/http/response/string_body_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe HTTP::Response::StringBody do
+  subject(:body) { described_class.new "Hello, World!" }
+
+  it "has the content" do
+    expect(subject.to_s).to eq "Hello, World!"
+  end
+
+  context "when body empty" do
+    subject(:body) { described_class.new "" }
+
+    it "returns responds to empty? with true" do
+      expect(subject).to be_empty
+    end
+  end
+
+  describe "#readpartial" do
+    context "with size given" do
+      it "returns only that amount" do
+        expect(body.readpartial(4)).to eq "Hell"
+      end
+    end
+
+    context "without size given" do
+      it "returns parts of the full content" do
+        expect(body.readpartial).to eq "Hello, World!"
+      end
+    end
+  end
+
+  describe "#each" do
+    it "yields contents" do
+      expect { |b| body.each(&b) }.to yield_with_args "Hello, World!"
+    end
+  end
+end

data/spec/lib/http/response_spec.rb

@@ -1,98 +1,117 @@
 RSpec.describe HTTP::Response do
-  it 'includes HTTP::Headers::Mixin' do
+  let(:body)          { "Hello world!" }
+  subject(:response)  { HTTP::Response.new 200, "1.1", {}, body }
+
+  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) }
+  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])
+    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 }
+  describe "mime_type" do
+    subject { HTTP::Response.new(200, "1.1", headers, "").mime_type }
 
-    context 'without Content-Type header' do
+    context "without Content-Type header" do
       let(:headers) { {} }
       it { is_expected.to be_nil }
     end
 
-    context 'with Content-Type: text/html' do
-      let(:headers) { {'Content-Type' => 'text/html'} }
-      it { is_expected.to eq 'text/html' }
+    context "with Content-Type: text/html" do
+      let(:headers) { {"Content-Type" => "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 { is_expected.to eq 'text/html' }
+    context "with Content-Type: text/html; charset=utf-8" do
+      let(:headers) { {"Content-Type" => "text/html; charset=utf-8"} }
+      it { is_expected.to eq "text/html" }
     end
   end
 
-  describe 'charset' do
-    subject { HTTP::Response.new(200, '1.1', headers, '').charset }
+  describe "charset" do
+    subject { HTTP::Response.new(200, "1.1", headers, "").charset }
 
-    context 'without Content-Type header' do
+    context "without Content-Type header" do
       let(:headers) { {} }
       it { is_expected.to be_nil }
     end
 
-    context 'with Content-Type: text/html' do
-      let(:headers) { {'Content-Type' => 'text/html'} }
+    context "with Content-Type: text/html" do
+      let(:headers) { {"Content-Type" => "text/html"} }
       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 { is_expected.to eq 'utf-8' }
+    context "with Content-Type: text/html; charset=utf-8" do
+      let(:headers) { {"Content-Type" => "text/html; charset=utf-8"} }
+      it { is_expected.to eq "utf-8" }
     end
   end
 
-  describe '#parse' do
-    let(:headers)   { {'Content-Type' => content_type} }
+  describe "#parse" do
+    let(:headers)   { {"Content-Type" => content_type} }
     let(:body)      { '{"foo":"bar"}' }
-    let(:response)  { HTTP::Response.new 200, '1.1', headers, body }
+    let(:response)  { HTTP::Response.new 200, "1.1", headers, body }
 
-    context 'with known content type' do
-      let(:content_type) { 'application/json' }
-      it 'returns parsed body' do
-        expect(response.parse).to eq 'foo' => 'bar'
+    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 'with unknown content type' do
-      let(:content_type) { 'application/deadbeef' }
-      it 'raises HTTP::Error' do
+    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'
+    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 'supports MIME type aliases' do
-        expect(response.parse :json).to eq 'foo' => 'bar'
+      it "supports MIME type aliases" do
+        expect(response.parse :json).to eq "foo" => "bar"
       end
     end
   end
 
-  describe '#flush' do
-    let(:body)      { double :to_s => '' }
-    let(:response)  { HTTP::Response.new 200, '1.1', {}, body }
+  describe "#flush" do
+    let(:body)      { double :to_s => "" }
+    let(:response)  { HTTP::Response.new 200, "1.1", {}, body }
 
-    it 'returns response self-reference' do
+    it "returns response self-reference" do
       expect(response.flush).to be response
     end
 
-    it 'flushes body' do
+    it "flushes body" do
       expect(body).to receive :to_s
       response.flush
     end
   end
+
+  describe "#inspect" do
+    it "returns human0friendly response representation" do
+      headers   = {:content_type => "text/plain"}
+      body      = double :to_s => "foobar"
+      response  = HTTP::Response.new(200, "1.1", headers, body)
+
+      expect(response.inspect)
+        .to eq '#<HTTP::Response/1.1 200 OK {"Content-Type"=>"text/plain"}>'
+    end
+  end
+
+  describe "#caching" do
+    subject { response.caching }
+    it { is_expected.to be_a HTTP::Response::Caching }
+  end
 end

data/spec/lib/http_spec.rb

@@ -1,139 +1,166 @@
-require 'json'
+require "json"
+
+require "support/dummy_server"
+require "support/proxy_server"
 
 RSpec.describe HTTP do
-  let(:test_endpoint)  { "http://#{ExampleServer::ADDR}" }
+  run_server(:dummy) { DummyServer.new }
 
-  context 'getting resources' do
-    it 'is easy' do
-      response = HTTP.get test_endpoint
+  context "getting resources" do
+    it "is easy" do
+      response = HTTP.get dummy.endpoint
       expect(response.to_s).to match(/<!doctype html>/)
     end
 
-    context 'with URI instance' do
-      it 'is easy' do
-        response = HTTP.get URI test_endpoint
+    context "with URI instance" do
+      it "is easy" do
+        response = HTTP.get URI dummy.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'}
+    context "with query string parameters" do
+      it "is easy" do
+        response = HTTP.get "#{dummy.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'}
+    context "with query string parameters in the URI and opts hash" do
+      it "includes both" do
+        response = HTTP.get "#{dummy.endpoint}/multiple-params?foo=bar", :params => {:baz => "quux"}
         expect(response.to_s).to match(/More Params!/)
       end
     end
 
-    context 'with headers' do
-      it 'is easy' do
-        response = HTTP.accept('application/json').get test_endpoint
-        expect(response.to_s.include?('json')).to be true
+    context "with headers" do
+      it "is easy" do
+        response = HTTP.accept("application/json").get dummy.endpoint
+        expect(response.to_s.include?("json")).to be true
       end
     end
   end
 
-  context 'with http proxy address and port' 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
+  describe ".via" do
+    context "anonymous proxy" do
+      run_server(:proxy) { ProxyServer.new }
 
-  context 'with http proxy address, port username and password' 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
+      it "proxies the request" do
+        response = HTTP.via(proxy.addr, proxy.port).get dummy.endpoint
+        expect(response.headers["X-Proxied"]).to eq "true"
+      end
 
-    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
+      it "responds with the endpoint's body" do
+        response = HTTP.via(proxy.addr, proxy.port).get dummy.endpoint
+        expect(response.to_s).to match(/<!doctype html>/)
+      end
 
-  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)
+      it "raises an argument error if no port given" do
+        expect { HTTP.via(proxy.addr) }.to raise_error HTTP::RequestError
+      end
+
+      it "ignores credentials" do
+        response = HTTP.via(proxy.addr, proxy.port, "username", "password").get dummy.endpoint
+        expect(response.to_s).to match(/<!doctype html>/)
+      end
     end
-  end
 
-  context 'without proxy port' do
-    it 'raises an argument error' do
-      expect { HTTP.via('127.0.0.1') }.to raise_error HTTP::RequestError
+    context "proxy with authentication" do
+      run_server(:proxy) { AuthProxyServer.new }
+
+      it "proxies the request" do
+        response = HTTP.via(proxy.addr, proxy.port, "username", "password").get dummy.endpoint
+        expect(response.headers["X-Proxied"]).to eq "true"
+      end
+
+      it "responds with the endpoint's body" do
+        response = HTTP.via(proxy.addr, proxy.port, "username", "password").get dummy.endpoint
+        expect(response.to_s).to match(/<!doctype html>/)
+      end
+
+      it "responds with 407 when wrong credentials given" do
+        response = HTTP.via(proxy.addr, proxy.port, "user", "pass").get dummy.endpoint
+        expect(response.status).to eq(407)
+      end
+
+      it "responds with 407 if no credentials given" do
+        response = HTTP.via(proxy.addr, proxy.port).get dummy.endpoint
+        expect(response.status).to eq(407)
+      end
     end
   end
 
-  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 :)')
+  context "posting forms to resources" do
+    it "is easy" do
+      response = HTTP.post "#{dummy.endpoint}/form", :form => {:example => "testing-form"}
+      expect(response.to_s).to eq("passed :)")
     end
   end
 
-  context 'posting with an explicit body' do
-    it 'is easy' do
-      response = HTTP.post "#{test_endpoint}/body", :body => 'testing-body'
-      expect(response.to_s).to eq('passed :)')
+  context "posting with an explicit body" do
+    it "is easy" do
+      response = HTTP.post "#{dummy.endpoint}/body", :body => "testing-body"
+      expect(response.to_s).to eq("passed :)")
     end
   end
 
-  context 'with redirects' do
-    it 'is easy for 301' do
-      response = HTTP.with_follow(true).get("#{test_endpoint}/redirect-301")
+  context "with redirects" do
+    it "is easy for 301" do
+      response = HTTP.with_follow(true).get("#{dummy.endpoint}/redirect-301")
       expect(response.to_s).to match(/<!doctype html>/)
     end
 
-    it 'is 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("#{dummy.endpoint}/redirect-302")
       expect(response.to_s).to match(/<!doctype html>/)
     end
-
   end
 
-  context 'head requests' do
-    it 'is easy' do
-      response = HTTP.head test_endpoint
+  context "head requests" do
+    it "is easy" do
+      response = HTTP.head dummy.endpoint
       expect(response.status).to eq(200)
-      expect(response['content-type']).to match(/html/)
+      expect(response["content-type"]).to match(/html/)
     end
   end
 
-  describe '.auth' do
-    it 'sets Authorization header to the given value' do
-      client = HTTP.auth 'abc'
-      expect(client.default_headers[:authorization]).to eq 'abc'
+  describe ".auth" do
+    it "sets Authorization header to the given value" do
+      client = HTTP.auth "abc"
+      expect(client.default_headers[:authorization]).to eq "abc"
     end
 
-    it 'accepts any #to_s object' do
-      client = HTTP.auth double :to_s => 'abc'
-      expect(client.default_headers[:authorization]).to eq 'abc'
+    it "accepts any #to_s object" do
+      client = HTTP.auth double :to_s => "abc"
+      expect(client.default_headers[:authorization]).to eq "abc"
     end
   end
 
-  describe '.basic_auth' do
-    it 'fails when options is not a Hash' do
-      expect { HTTP.basic_auth '[FOOBAR]' }.to raise_error
+  describe ".basic_auth" do
+    it "fails when options is not a Hash" do
+      expect { HTTP.basic_auth "[FOOBAR]" }.to raise_error
     end
 
-    it 'fails when :pass is not given' do
-      expect { HTTP.basic_auth :user => '[USER]' }.to raise_error
+    it "fails when :pass is not given" do
+      expect { HTTP.basic_auth :user => "[USER]" }.to raise_error
     end
 
-    it 'fails when :user is not given' do
-      expect { HTTP.basic_auth :pass => '[PASS]' }.to raise_error
+    it "fails when :user is not given" do
+      expect { HTTP.basic_auth :pass => "[PASS]" }.to raise_error
     end
 
-    it 'sets Authorization header with proper BasicAuth value' do
-      client = HTTP.basic_auth :user => 'foo', :pass => 'bar'
+    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
+
+  describe ".with_cache" do
+    it "sets cache option" do
+      cache = double(:cache, :perform => nil)
+      client = HTTP.with_cache cache
+      expect(client.default_options[:cache]).to eq cache
+    end
+  end
 end