http 0.8.14 → 0.9.0.pre

data/spec/lib/http/cache_spec.rb

@@ -1,182 +0,0 @@
-require "support/dummy_server"
-require "http/cache"
-
-RSpec.describe HTTP::Cache do
-  describe "creation" do
-    subject { described_class }
-
-    it "allows metastore and entitystore" do
-      expect(subject.new(:metastore => "heap:/", :entitystore => "heap:/")).
-        to be_kind_of HTTP::Cache
-    end
-  end
-
-  let(:opts) { options }
-  let(:sn) { SecureRandom.urlsafe_base64(3) }
-  let(:request) { HTTP::Request.new(:get, "http://example.com/#{sn}") }
-
-  let(:origin_response) do
-    HTTP::Response.new(200,
-                       "http/1.1",
-                       {"Cache-Control" => "private"},
-                       "origin")
-  end
-
-  subject { described_class.new(:metastore => "heap:/", :entitystore => "heap:/") }
-
-  describe "#perform" do
-    it "calls request_performer blocck when cache miss" do
-      expect do |b|
-        subject.perform(request, opts) do |*args|
-          b.to_proc.call(*args)
-          origin_response
-        end
-      end.to yield_with_args(request, opts)
-    end
-
-    context "cache hit" do
-      it "does not call request_performer block" do
-        subject.perform(request, opts) do |*_t|
-          origin_response
-        end
-
-        expect { |b| subject.perform(request, opts, &b) }.not_to yield_control
-      end
-    end
-  end
-
-  context "empty cache, cacheable request, cacheable response" do
-    let!(:response) { subject.perform(request, opts) { origin_response } }
-
-    it "returns origin servers response" do
-      expect(response).to eq origin_response
-    end
-  end
-
-  context "cache by-passing request, cacheable response" do
-    let(:request) do
-      headers = {"Cache-Control" => "no-cache"}
-      HTTP::Request.new(:get, "http://example.com/", headers)
-    end
-    let!(:response) { subject.perform(request, opts) { origin_response } }
-
-    it "returns origin servers response" do
-      expect(response).to eq origin_response
-    end
-  end
-
-  context "empty cache, cacheable request, 'no-cache' response" do
-    let(:origin_response) do
-      HTTP::Response.new(200,
-                         "http/1.1",
-                         {"Cache-Control" => "no-store"},
-                         "")
-    end
-    let!(:response) { subject.perform(request, opts) { origin_response } }
-
-    it "returns origin servers response" do
-      expect(response).to eq origin_response
-    end
-  end
-
-  context "empty cache, cacheable request, 'no-store' response" do
-    let(:origin_response) do
-      HTTP::Response.new(200,
-                         "http/1.1",
-                         {"Cache-Control" => "no-store"},
-                         "")
-    end
-    let!(:response) { subject.perform(request, opts) { origin_response } }
-
-    it "returns origin servers response" do
-      expect(response).to eq origin_response
-    end
-  end
-
-  context "warm cache, cacheable request, cacheable response" do
-    let(:cached_response) do
-      build_cached_response(200,
-                            "1.1",
-                            {"Cache-Control" => "max-age=100"},
-                            "cached")
-    end
-    before do
-      subject.perform(request, opts) { cached_response }
-    end
-
-    let(:response) { subject.perform(request, opts) { origin_response } }
-
-    it "returns cached response" do
-      expect(response.body.to_s).to eq cached_response.body.to_s
-    end
-  end
-
-  context "stale cache, cacheable request, cacheable response" do
-    let(:cached_response) do
-      build_cached_response(200,
-                            "1.1",
-                            {"Cache-Control" => "private, max-age=1",
-                             "Date" => (Time.now - 2).httpdate},
-                            "cached") do |t|
-        t.requested_at = (Time.now - 2)
-      end
-    end
-    before do
-      subject.perform(request, opts) { cached_response }
-    end
-    let(:response) { subject.perform(request, opts) { origin_response } }
-
-    it "returns origin servers response" do
-      expect(response.body.to_s).to eq origin_response.body.to_s
-    end
-  end
-
-  context "stale cache, cacheable request, not modified response" do
-    let(:cached_response) do
-      build_cached_response(200,
-                            "http/1.1",
-                            {"Cache-Control" => "private, max-age=1",
-                             "Etag" => "foo",
-                             "Date" => (Time.now - 2).httpdate},
-                            "") do |x|
-        x.requested_at = (Time.now - 2)
-      end
-    end
-    before do
-      subject.perform(request, opts) { cached_response }
-    end
-
-    let(:origin_response) { HTTP::Response.new(304, "http/1.1", {}, "") }
-    let(:response) { subject.perform(request, opts) { origin_response } }
-
-    it "makes request with conditional request headers" do
-      subject.perform(request, opts) do |actual_request, _|
-        expect(actual_request.headers["If-None-Match"]).
-          to eq cached_response.headers["Etag"]
-        expect(actual_request.headers["If-Modified-Since"]).
-          to eq cached_response.headers["Last-Modified"]
-
-        origin_response
-      end
-    end
-
-    it "returns cached servers response" do
-      expect(response.body.to_s).to eq cached_response.body.to_s
-    end
-  end
-
-  let(:cached_response) { nil } # cold cache by default
-
-  def build_cached_response(*args)
-    r = HTTP::Response.new(*args).caching
-    r.requested_at = r.received_at = Time.now
-
-    yield r if block_given?
-
-    r
-  end
-
-  def options
-    HTTP::Options.new
-  end
-end

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

@@ -1,133 +0,0 @@
-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

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

@@ -1,201 +0,0 @@
-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