http 0.7.4 → 0.8.0.pre

data/spec/lib/http/request/writer_spec.rb

@@ -2,84 +2,84 @@
 
 RSpec.describe HTTP::Request::Writer do
   let(:io)          { StringIO.new }
-  let(:body)        { '' }
+  let(:body)        { "" }
   let(:headers)     { HTTP::Headers.new }
-  let(:headerstart) { 'GET /test HTTP/1.1' }
+  let(:headerstart) { "GET /test HTTP/1.1" }
 
   subject(:writer)  { described_class.new(io, body, headers, headerstart) }
 
-  describe '#initalize' do
-    context 'when body is nil' do
+  describe "#initalize" do
+    context "when body is nil" do
       let(:body) { nil }
 
-      it 'does not raise an error' do
+      it "does not raise an error" do
         expect { writer }.not_to raise_error
       end
     end
 
-    context 'when body is a string' do
-      let(:body) { 'string body' }
+    context "when body is a string" do
+      let(:body) { "string body" }
 
-      it 'does not raise an error' do
+      it "does not raise an error" do
         expect { writer }.not_to raise_error
       end
     end
 
-    context 'when body is an Enumerable' do
+    context "when body is an Enumerable" do
       let(:body) { %w(bees cows) }
 
-      it 'does not raise an error' do
+      it "does not raise an error" do
         expect { writer }.not_to raise_error
       end
     end
 
-    context 'when body is not string, enumerable or nil' do
+    context "when body is not string, enumerable or nil" do
       let(:body) { 123 }
 
-      it 'raises an error' do
+      it "raises an error" do
         expect { writer }.to raise_error
       end
     end
   end
 
-  describe '#stream' do
-    context 'when body is Enumerable' do
+  describe "#stream" do
+    context "when body is Enumerable" do
       let(:body)    { %w(bees cows) }
-      let(:headers) { HTTP::Headers.coerce 'Transfer-Encoding' => 'chunked' }
+      let(:headers) { HTTP::Headers.coerce "Transfer-Encoding" => "chunked" }
 
-      it 'writes a chunked request from an Enumerable correctly' do
+      it "writes a chunked request from an Enumerable correctly" do
         writer.stream
         expect(io.string).to end_with "\r\n4\r\nbees\r\n4\r\ncows\r\n0\r\n\r\n"
       end
 
-      it 'writes Transfer-Encoding header only once' do
+      it "writes Transfer-Encoding header only once" do
         writer.stream
         expect(io.string).to start_with "#{headerstart}\r\nTransfer-Encoding: chunked\r\n\r\n"
       end
 
-      context 'when Transfer-Encoding not set' do
+      context "when Transfer-Encoding not set" do
         let(:headers) { HTTP::Headers.new }
         specify { expect { writer.stream }.to raise_error }
       end
 
-      context 'when Transfer-Encoding is not chunked' do
-        let(:headers) { HTTP::Headers.coerce 'Transfer-Encoding' => 'gzip' }
+      context "when Transfer-Encoding is not chunked" do
+        let(:headers) { HTTP::Headers.coerce "Transfer-Encoding" => "gzip" }
         specify { expect { writer.stream }.to raise_error }
       end
     end
 
-    context 'when body is a unicode String' do
-      let(:body) { 'Привет, мир!' }
+    context "when body is a unicode String" do
+      let(:body) { "Привет, мир!" }
 
-      it 'properly calculates Content-Length if needed' do
+      it "properly calculates Content-Length if needed" do
         writer.stream
         expect(io.string).to start_with "#{headerstart}\r\nContent-Length: 21\r\n\r\n"
       end
 
-      context 'when Content-Length explicitly set' do
-        let(:headers) { HTTP::Headers.coerce 'Content-Length' => 12 }
+      context "when Content-Length explicitly set" do
+        let(:headers) { HTTP::Headers.coerce "Content-Length" => 12 }
 
-        it 'keeps given value' do
+        it "keeps given value" do
           writer.stream
           expect(io.string).to start_with "#{headerstart}\r\nContent-Length: 12\r\n\r\n"
         end

data/spec/lib/http/request_spec.rb

@@ -1,141 +1,146 @@
 RSpec.describe HTTP::Request do
-  let(:headers)     { {:accept => 'text/html'} }
-  let(:request_uri) { 'http://example.com/' }
+  let(:headers)     { {:accept => "text/html"} }
+  let(:request_uri) { "http://example.com/" }
 
   subject(:request) { HTTP::Request.new(:get, request_uri, headers) }
 
-  it 'includes HTTP::Headers::Mixin' do
+  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 \
+  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
+  it "provides a #scheme accessor" do
     expect(request.scheme).to eq(:http)
   end
 
-  it 'provides a #verb accessor' do
+  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
+  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')
+  it "sets given headers" do
+    expect(subject["Accept"]).to eq("text/html")
   end
 
-  describe 'Host header' do
-    subject { request['Host'] }
+  describe "Host header" do
+    subject { request["Host"] }
 
-    context 'was not given' do
-      it { is_expected.to eq 'example.com' }
+    context "was not given" do
+      it { is_expected.to eq "example.com" }
 
-      context 'and request URI has non-standard port' do
-        let(:request_uri) { 'http://example.com:3000/' }
-        it { is_expected.to eq 'example.com:3000' }
+      context "and request URI has non-standard port" do
+        let(:request_uri) { "http://example.com:3000/" }
+        it { is_expected.to eq "example.com:3000" }
       end
     end
 
-    context 'was explicitly given' do
-      before { headers[:host] = 'github.com' }
-      it { is_expected.to eq 'github.com' }
+    context "was explicitly given" do
+      before { headers[:host] = "github.com" }
+      it { is_expected.to eq "github.com" }
     end
   end
 
-  describe 'User-Agent header' do
-    subject { request['User-Agent'] }
+  describe "User-Agent header" do
+    subject { request["User-Agent"] }
 
-    context 'was not given' do
+    context "was not given" do
       it { is_expected.to eq HTTP::Request::USER_AGENT }
     end
 
-    context 'was explicitly given' do
-      before { headers[:user_agent] = 'MrCrawly/123' }
-      it { is_expected.to eq 'MrCrawly/123' }
+    context "was explicitly given" do
+      before { headers[:user_agent] = "MrCrawly/123" }
+      it { is_expected.to eq "MrCrawly/123" }
     end
   end
 
-  describe '#redirect' do
-    let(:headers)   { {:accept => 'text/html'} }
-    let(:proxy)     { {:proxy_username => 'douglas', :proxy_password => 'adams'} }
-    let(:body)      { 'The Ultimate Question' }
-    let(:request)   { HTTP::Request.new(:post, 'http://example.com/', headers, proxy, body) }
+  describe "#redirect" do
+    let(:headers)   { {:accept => "text/html"} }
+    let(:proxy)     { {:proxy_username => "douglas", :proxy_password => "adams"} }
+    let(:body)      { "The Ultimate Question" }
+    let(:request)   { HTTP::Request.new(:post, "http://example.com/", headers, proxy, body) }
 
-    subject(:redirected) { request.redirect 'http://blog.example.com/' }
+    subject(:redirected) { request.redirect "http://blog.example.com/" }
 
-    its(:uri)     { is_expected.to eq URI.parse 'http://blog.example.com/' }
+    its(:uri)     { is_expected.to eq URI.parse "http://blog.example.com/" }
 
     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'
+    it "presets new Host header" do
+      expect(redirected["Host"]).to eq "blog.example.com"
     end
 
-    context 'with schema-less absolute URL given' do
-      subject(:redirected) { request.redirect '//another.example.com/blog' }
+    context "with schema-less absolute URL given" do
+      subject(:redirected) { request.redirect "//another.example.com/blog" }
 
-      its(:uri)     { is_expected.to eq URI.parse 'http://another.example.com/blog' }
+      its(:uri)     { is_expected.to eq URI.parse "http://another.example.com/blog" }
 
       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'
+      it "presets new Host header" do
+        expect(redirected["Host"]).to eq "another.example.com"
       end
     end
 
-    context 'with relative URL given' do
-      subject(:redirected) { request.redirect '/blog' }
+    context "with relative URL given" do
+      subject(:redirected) { request.redirect "/blog" }
 
-      its(:uri)     { is_expected.to eq URI.parse 'http://example.com/blog' }
+      its(:uri)     { is_expected.to eq URI.parse "http://example.com/blog" }
 
       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'
+      it "keeps Host header" do
+        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)     { is_expected.to eq URI.parse 'http://example.com:8080/blog' }
+      context "with original URI having non-standard port" do
+        let(:request) { HTTP::Request.new(:post, "http://example.com:8080/", headers, proxy, body) }
+        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' }
+    context "with relative URL that misses leading slash given" do
+      subject(:redirected) { request.redirect "blog" }
 
-      its(:uri)     { is_expected.to eq URI.parse 'http://example.com/blog' }
+      its(:uri)     { is_expected.to eq URI.parse "http://example.com/blog" }
 
       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'
+      it "keeps Host header" do
+        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)     { is_expected.to eq URI.parse 'http://example.com:8080/blog' }
+      context "with original URI having non-standard port" do
+        let(:request) { HTTP::Request.new(:post, "http://example.com:8080/", headers, proxy, body) }
+        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 }
+    context "with new verb given" do
+      subject { request.redirect "http://blog.example.com/", :get }
       its(:verb) { is_expected.to be :get }
     end
   end
+
+  describe "#caching" do
+    subject { request.caching }
+    it { is_expected.to be_a HTTP::Request::Caching }
+  end
 end

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

@@ -1,37 +1,37 @@
 RSpec.describe HTTP::Response::Body do
-  let(:client)   { double }
-  let(:chunks)   { ['Hello, ', 'World!'] }
+  let(:client)   { double(:sequence_id => 0) }
+  let(:chunks)   { ["Hello, ", "World!"] }
 
   before         { allow(client).to receive(:readpartial) { chunks.shift } }
 
   subject(:body) { described_class.new client }
 
-  it 'streams bodies from responses' do
-    expect(subject.to_s).to eq 'Hello, World!'
+  it "streams bodies from responses" do
+    expect(subject.to_s).to eq "Hello, World!"
   end
 
-  context 'when body empty' do
-    let(:chunks) { [''] }
+  context "when body empty" do
+    let(:chunks) { [""] }
 
-    it 'returns responds to empty? with true' do
+    it "returns responds to empty? with true" do
       expect(subject).to be_empty
     end
   end
 
-  describe '#readpartial' do
-    context 'with size given' do
-      it 'passes value to underlying client' do
+  describe "#readpartial" do
+    context "with size given" do
+      it "passes value to underlying client" do
         expect(client).to receive(:readpartial).with(42)
         body.readpartial 42
       end
     end
 
-    context 'without size given' do
-      it 'does not blows up' do
+    context "without size given" do
+      it "does not blows up" do
         expect { body.readpartial }.to_not raise_error
       end
 
-      it 'calls underlying client readpartial without specific size' do
+      it "calls underlying client readpartial without specific size" do
         expect(client).to receive(:readpartial).with no_args
         body.readpartial
       end

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

@@ -0,0 +1,201 @@
+RSpec.describe HTTP::Response::Caching do
+  let(:cache_control) { "" }
+  let(:headers) { {"cache-control" => cache_control} }
+  let(:response) { HTTP::Response.new(200, "http/1.1", headers, "") }
+
+  subject(:caching_response) { described_class.new response }
+
+  describe "#cache_headers" do
+    subject { caching_response.cache_headers }
+    it { is_expected.to be_a HTTP::Cache::Headers }
+  end
+
+  it "allows requested_at to be set" do
+    subject.requested_at = Time.now
+    expect(subject.requested_at).to be_within(1).of(Time.now)
+  end
+
+  it "allows received_at to be set" do
+    subject.received_at = Time.now
+    expect(subject.received_at).to be_within(1).of(Time.now)
+  end
+
+  describe "basic 200 response w/ private cache control" do
+    let(:cache_control) { "private" }
+
+    it "is cacheable" do
+      expect(subject.cacheable?).to be_truthy
+    end
+
+    it "is not stale" do
+      expect(subject.stale?).to be_falsy
+    end
+
+    it "is not expired" do
+      expect(subject.expired?).to be_falsy
+    end
+
+    it "is expected to be 0 seconds old" do
+      expect(subject.current_age).to be_within(1).of(0)
+    end
+  end
+
+  describe "basic 200 response w/ public cache control" do
+    let(:cache_control) { "public" }
+
+    it "is cacheable" do
+      expect(subject.cacheable?).to be_truthy
+    end
+
+    it "is not stale" do
+      expect(subject.stale?).to be_falsy
+    end
+
+    it "is not expired" do
+      expect(subject.expired?).to be_falsy
+    end
+
+    it "is expected to be 0 seconds old" do
+      expect(subject.current_age).to be_within(1).of(0)
+    end
+  end
+
+  describe "basic 200 response w/ no-cache" do
+    let(:cache_control) { "no-cache" }
+
+    it "is not cacheable" do
+      expect(subject.cacheable?).to be_falsy
+    end
+
+    it "is not stale" do
+      expect(subject.stale?).to be_falsy
+    end
+
+    it "is not expired" do
+      expect(subject.expired?).to be_falsy
+    end
+
+    it "is expected to be 0 seconds old" do
+      expect(subject.current_age).to be_within(1).of(0)
+    end
+  end
+
+  describe "basic 200 response w/ no-store" do
+    let(:cache_control) { "no-store" }
+
+    it "is not cacheable" do
+      expect(subject.cacheable?).to be_falsy
+    end
+
+    it "is not stale" do
+      expect(subject.stale?).to be_falsy
+    end
+
+    it "is not expired" do
+      expect(subject.expired?).to be_falsy
+    end
+
+    it "is expected to be 0 seconds old" do
+      expect(subject.current_age).to be_within(1).of(0)
+    end
+  end
+
+  describe "basic 200 response w/ max age" do
+    let(:cache_control) { "max-age=100" }
+
+    it "is not cacheable" do
+      expect(subject.cacheable?).to be_truthy
+    end
+
+    it "is not stale" do
+      expect(subject.stale?).to be_falsy
+    end
+
+    it "is not expired" do
+      expect(subject.expired?).to be_falsy
+    end
+
+    it "is expected to be 0 seconds old" do
+      expect(subject.current_age).to be_within(1).of(0)
+    end
+  end
+
+  describe "basic 200 response w/ public & max age" do
+    let(:cache_control) { "public, max-age=100" }
+
+    it "is not cacheable" do
+      expect(subject.cacheable?).to be_truthy
+    end
+
+    it "is not stale" do
+      expect(subject.stale?).to be_falsy
+    end
+
+    it "is not expired" do
+      expect(subject.expired?).to be_falsy
+    end
+
+    it "is expected to be 0 seconds old" do
+      expect(subject.current_age).to be_within(1).of(0)
+    end
+
+    context "with age of max-age + 1 seconds" do
+      let(:headers) { {"cache-control" => cache_control, "age" => "101"} }
+
+      it "is stale" do
+        expect(subject.stale?).to be_truthy
+      end
+
+      it "is expired" do
+        expect(subject.expired?).to be_truthy
+      end
+
+      it "is expected to be max-age + 1 seconds old" do
+        expect(subject.current_age).to be_within(1).of(101)
+      end
+    end
+
+    context "after max-age + 1 seconds" do
+      before do
+        subject.received_at = subject.requested_at = (Time.now - 101)
+      end
+
+      it "is stale" do
+        expect(subject.stale?).to be_truthy
+      end
+
+      it "is expired" do
+        expect(subject.expired?).to be_truthy
+      end
+
+      it "is expected to be max-age + 1 seconds old" do
+        expect(subject.current_age).to be_within(1).of(101)
+      end
+    end
+  end
+
+  describe "basic 400 response " do
+    let(:response) { HTTP::Response.new(400, "http/1.1", {}, "") }
+
+    it "is not cacheable" do
+      expect(subject.cacheable?).to be_falsy
+    end
+
+    it "is not stale" do
+      expect(subject.stale?).to be_falsy
+    end
+
+    it "is not expired" do
+      expect(subject.expired?).to be_falsy
+    end
+
+    it "is expected to be 0 seconds old" do
+      expect(subject.current_age).to be_within(1).of(0)
+    end
+  end
+
+  describe "#caching" do
+    subject(:caching_response) { response.caching }
+    it { is_expected.to be_kind_of described_class }
+  end
+end