http 0.7.4 → 0.8.0.pre

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

@@ -1,13 +1,13 @@
-RSpec.describe HTTP::Options, 'body' do
+RSpec.describe HTTP::Options, "body" do
   let(:opts) { HTTP::Options.new }
 
-  it 'defaults to nil' do
+  it "defaults to nil" do
     expect(opts.body).to be nil
   end
 
-  it 'may be specified with with_body' do
-    opts2 = opts.with_body('foo')
+  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')
+    expect(opts2.body).to eq("foo")
   end
 end

data/spec/lib/http/options/form_spec.rb

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

data/spec/lib/http/options/headers_spec.rb

@@ -1,18 +1,18 @@
-RSpec.describe HTTP::Options, 'headers' do
+RSpec.describe HTTP::Options, "headers" do
   let(:opts) { HTTP::Options.new }
 
-  it 'defaults to be empty' do
+  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')
+  it "may be specified with with_headers" do
+    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')
+  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
 end

data/spec/lib/http/options/json_spec.rb

@@ -1,11 +1,11 @@
-RSpec.describe HTTP::Options, 'json' do
+RSpec.describe HTTP::Options, "json" do
   let(:opts) { HTTP::Options.new }
 
-  it 'defaults to nil' do
+  it "defaults to nil" do
     expect(opts.json).to be nil
   end
 
-  it 'may be specified with with_json data' do
+  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)

data/spec/lib/http/options/merge_spec.rb

@@ -1,49 +1,53 @@
-RSpec.describe HTTP::Options, 'merge' do
+
+RSpec.describe HTTP::Options, "merge" do
   let(:opts) { HTTP::Options.new }
 
-  it 'supports a Hash' do
+  it "supports a Hash" do
     old_response = opts.response
     expect(opts.merge(:response => :body).response).to eq(:body)
     expect(opts.response).to eq(old_response)
   end
 
-  it 'supports another Options' do
+  it "supports another Options" do
     merged = opts.merge(HTTP::Options.new(:response => :body))
     expect(merged.response).to eq(:body)
   end
 
-  it 'merges as excepted in complex cases' do
+  it "merges as excepted in complex cases" do
     # FIXME: yuck :(
 
     foo = HTTP::Options.new(
       :response  => :body,
-      :params      => {:baz => 'bar'},
-      :form      => {:foo => 'foo'},
-      :body      => 'body-foo',
-      :json      => {:foo => 'foo'},
-      :headers   => {:accept  => 'json',  :foo => 'foo'},
+      :params      => {:baz => "bar"},
+      :form      => {:foo => "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',
-      :json      => {:bar => 'bar'},
-      :headers   => {:accept  => 'xml', :bar => 'bar'},
-      :proxy     => {:proxy_address => '127.0.0.1', :proxy_port => 8080})
+      :persistent  => "https://www.googe.com",
+      :params      => {:plop => "plip"},
+      :form      => {:bar => "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'},
-      :form      => {:bar => 'bar'},
-      :body      => 'body-bar',
-      :json      => {:bar => 'bar'},
-      :headers   => {'Accept'  => 'xml', 'Foo' => 'foo', 'Bar' => 'bar'},
-      :proxy     => {:proxy_address => '127.0.0.1', :proxy_port => 8080},
+      :params    => {:plop => "plip"},
+      :form      => {:bar => "bar"},
+      :body      => "body-bar",
+      :json      => {:bar => "bar"},
+      :persistent  => "https://www.googe.com",
+      :headers   => {"Foo" => "foo", "Accept"  => "xml", "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,
+      :cache      => described_class.default_cache)
   end
 end

data/spec/lib/http/options/new_spec.rb

@@ -1,26 +1,26 @@
-RSpec.describe HTTP::Options, 'new' do
-  it 'supports a Options instance' do
+RSpec.describe HTTP::Options, "new" do
+  it "supports a Options instance" do
     opts = HTTP::Options.new
     expect(HTTP::Options.new(opts)).to eq(opts)
   end
 
-  context 'with a Hash' do
-    it 'coerces :response correctly' do
+  context "with a Hash" do
+    it "coerces :response correctly" do
       opts = HTTP::Options.new(:response => :object)
       expect(opts.response).to eq(:object)
     end
 
-    it 'coerces :headers correctly' do
-      opts = HTTP::Options.new(:headers => {:accept => 'json'})
+    it "coerces :headers correctly" do
+      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)
+    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)
     end
 
-    it 'coerces :form correctly' do
+    it "coerces :form correctly" do
       opts = HTTP::Options.new(:form => {:foo => 42})
       expect(opts.form).to eq(:foo => 42)
     end

data/spec/lib/http/options/proxy_spec.rb

@@ -1,18 +1,18 @@
-RSpec.describe HTTP::Options, 'proxy' do
+RSpec.describe HTTP::Options, "proxy" do
   let(:opts) { HTTP::Options.new }
 
-  it 'defaults to {}' do
+  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)
+  it "may be specified with with_proxy" do
+    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')
+  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")
   end
 end

data/spec/lib/http/options_spec.rb

@@ -1,12 +1,12 @@
 RSpec.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
   end
 
-  it 'coerces to a Hash' do
+  it "coerces to a Hash" do
     expect(subject.to_hash).to be_a(Hash)
   end
 end

data/spec/lib/http/redirector_spec.rb

@@ -1,20 +1,20 @@
 RSpec.describe HTTP::Redirector do
-  def simple_response(status, body = '', headers = {})
-    HTTP::Response.new(status, '1.1', headers, body)
+  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
+    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 }
+  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
+    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
@@ -22,11 +22,11 @@ RSpec.describe HTTP::Redirector do
     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 }
+  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
+    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
@@ -34,11 +34,11 @@ RSpec.describe HTTP::Redirector do
     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 }
+  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
+    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
@@ -46,12 +46,12 @@ RSpec.describe HTTP::Redirector do
     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 }
+  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
+      it "follows without changing verb" do
         redirector.perform(orig_request, orig_response) do |request|
           expect(request.verb).to be :get
           simple_response 200
@@ -59,11 +59,11 @@ RSpec.describe HTTP::Redirector do
       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 }
+    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
+      it "follows without changing verb" do
         redirector.perform(orig_request, orig_response) do |request|
           expect(request.verb).to be :get
           simple_response 200
@@ -72,11 +72,11 @@ RSpec.describe HTTP::Redirector do
     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 }
+  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
+    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
@@ -84,11 +84,11 @@ RSpec.describe HTTP::Redirector do
     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 }
+  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
+    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

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

@@ -0,0 +1,133 @@
+RSpec.describe HTTP::Request::Caching do
+  let(:request) { HTTP::Request.new(:get, "http://example.com/") }
+
+  subject(:caching_request) { described_class.new request }
+
+  describe "#cache_headers" do
+    subject { caching_request.cache_headers }
+    it { is_expected.to be_a HTTP::Cache::Headers }
+  end
+
+  context "basic GET request" do
+    it "is cacheable" do
+      expect(subject.cacheable?).to be_truthy
+    end
+
+    it "does not invalidate cache" do
+      expect(subject.invalidates_cache?).to be_falsy
+    end
+
+    it "does not skip cache" do
+      expect(subject.skips_cache?).to be_falsy
+    end
+
+    it "can construct a new conditional version of itself based on a caching response" do
+      mod_date    = Time.now.httpdate
+      headers     = {"Etag" => "foo", "Last-Modified" => mod_date}
+      cached_resp = HTTP::Response.new(200, "http/1.1", headers, "")
+      cond_req = subject.conditional_on_changes_to(cached_resp)
+
+      expect(cond_req.headers["If-None-Match"]).to eq "foo"
+      expect(cond_req.headers["If-Modified-Since"]).to eq mod_date
+    end
+  end
+
+  context "GET request w/ must-revalidate" do
+    let(:request) do
+      headers = {"cache-control" => "must-revalidate"}
+      HTTP::Request.new(:get, "http://example.com/", headers)
+    end
+
+    it "is cacheable" do
+      expect(subject.cacheable?).to be_truthy
+    end
+
+    it "does not invalidate cache" do
+      expect(subject.invalidates_cache?).to be_falsy
+    end
+
+    it "does not skip cache" do
+      expect(subject.skips_cache?).to be_truthy
+    end
+
+    it "can construct a condition version of itself based on a caching response" do
+      mod_date    = Time.now.httpdate
+      headers     = {"Etag" => "foo", "Last-Modified" => mod_date}
+      cached_resp = HTTP::Response.new(200, "http/1.1", headers, "")
+      cond_req    = subject.conditional_on_changes_to(cached_resp)
+
+      expect(cond_req.headers["If-None-Match"]).to eq "foo"
+      expect(cond_req.headers["If-Modified-Since"]).to eq mod_date
+      expect(cond_req.cache_headers.max_age).to eq 0
+    end
+  end
+
+  context "basic POST request" do
+    let(:request) { HTTP::Request.new(:post, "http://example.com/") }
+
+    it "is cacheable" do
+      expect(subject.cacheable?).to be_falsy
+    end
+
+    it "does not invalidate cache" do
+      expect(subject.invalidates_cache?).to be_truthy
+    end
+
+    it "does not skip cache" do
+      expect(subject.skips_cache?).to be_falsy
+    end
+  end
+
+  context "basic PUT request" do
+    let(:request) { HTTP::Request.new(:put, "http://example.com/") }
+
+    it "is cacheable" do
+      expect(subject.cacheable?).to be_falsy
+    end
+
+    it "does not invalidate cache" do
+      expect(subject.invalidates_cache?).to be_truthy
+    end
+
+    it "does not skip cache" do
+      expect(subject.skips_cache?).to be_falsy
+    end
+  end
+
+  context "basic delete request" do
+    let(:request) { HTTP::Request.new(:delete, "http://example.com/") }
+
+    it "is cacheable" do
+      expect(subject.cacheable?).to be_falsy
+    end
+
+    it "does not invalidate cache" do
+      expect(subject.invalidates_cache?).to be_truthy
+    end
+
+    it "does not skip cache" do
+      expect(subject.skips_cache?).to be_falsy
+    end
+  end
+
+  context "basic patch request" do
+    let(:request) { HTTP::Request.new(:patch, "http://example.com/") }
+
+    it "is cacheable" do
+      expect(subject.cacheable?).to be_falsy
+    end
+
+    it "does not invalidate cache" do
+      expect(subject.invalidates_cache?).to be_truthy
+    end
+
+    it "does not skip cache" do
+      expect(subject.skips_cache?).to be_falsy
+    end
+  end
+
+  describe "#caching" do
+    subject(:caching_request) { request.caching }
+    it { is_expected.to be caching_request }
+  end
+end