cached_resource 8.0.0 → 9.0.0

data/spec/cached_resource/caching_spec.rb

@@ -1,602 +0,0 @@
-require 'spec_helper'
-
-describe CachedResource do
-
-  def read_from_cache(key)
-    Thing.send(:cache_read, key)
-  end
-
-  before(:each) do
-    class Thing < ActiveResource::Base
-      self.site = "http://api.thing.com"
-      cached_resource
-    end
-
-    class NotTheThing < ActiveResource::Base
-      self.site = "http://api.notthething.com"
-      cached_resource
-    end
-
-    @thing = {:thing => {:id => 1, :name => "Ada"}}
-    @thing_collection = [{:id => 1, :name => "Ada"}, {:id => 2, :name => "Ada", :major => 'CS'}]
-    @thing_collection2 = [{:id => 2, :name => "Ada", :major => 'CS'}]
-    @other_thing = {:thing => {:id => 1, :name => "Ari"}}
-    @thing2 = {:thing => {:id => 2, :name => "Joe"}}
-    @other_thing2 = {:thing => {:id => 2, :name => "Jeb"}}
-    @thing3 = {:thing => {:id => 3, :name => "Stu"}}
-    @string_thing = {:thing => {:id => "fded", :name => "Lev"}}
-    @other_string_thing = {:thing => {:id => "fded", :name => "Lon"}}
-    @date_thing = {:thing => {:id => 4, :created_at => DateTime.new(2020)}}
-    @thing_json = @thing.to_json
-    @other_thing_json = @other_thing.to_json
-    @string_thing_json = @string_thing.to_json
-    @other_string_thing_json = @other_string_thing.to_json
-    @date_thing_json = @date_thing.to_json
-    @nil_thing = nil.to_json
-    @empty_array_thing = [].to_json
-    @not_the_thing = {:not_the_thing => {:id => 1, :name => "Not"}}
-    @not_the_thing_json = @not_the_thing.to_json
-  end
-
-  after(:each) do
-    Thing.cached_resource.cache.clear
-    Object.send(:remove_const, :Thing)
-    NotTheThing.cached_resource.cache.clear
-    Object.send(:remove_const, :NotTheThing)
-  end
-
-  describe "when enabled" do
-    before(:each) do
-      # it's on by default, but lets call the method
-      # to make sure it works
-      Thing.cached_resource.cache.clear
-      Thing.cached_resource.on!
-      NotTheThing.cached_resource.cache.clear
-      NotTheThing.cached_resource.on!
-
-      ActiveResource::HttpMock.reset!
-      ActiveResource::HttpMock.respond_to do |mock|
-        mock.get "/things/1.json", {}, @thing_json
-        mock.get "/things/1.json?foo=bar", {}, @thing_json
-        mock.get "/things/fded.json", {}, @string_thing_json
-        mock.get "/things.json?name=42", {}, @nil_thing, 404
-        mock.get "/things.json?name=43", {}, @empty_array_thing
-        mock.get "/things/4.json", {}, @date_thing_json
-        mock.get "/not_the_things/1.json", {}, @not_the_thing_json
-      end
-    end
-
-    shared_examples "caching" do
-      it "should cache a response" do
-        result = Thing.find(1)
-        read_from_cache("thing/1").should == result
-      end
-
-      it "shouldn't cache nil response" do
-        Thing.find(:all, :params => { :name => '42' })
-        read_from_cache("thing/all/name/42").should == nil
-      end
-
-      it "shouldn't cache blank response" do
-        Thing.find(:all, :params => { :name => '43' })
-        read_from_cache("thing/all/name/43").should == nil
-      end
-    end
-
-    include_examples "caching"
-
-    context 'when concurrency is turned on' do
-      include_examples "caching"
-    end
-
-    it "should cache a response for a string primary key" do
-      result = Thing.find("fded")
-      read_from_cache("thing/fded").should == result
-    end
-
-    it "should cache without whitespace in keys" do
-      result = Thing.find(1, :from => 'path', :params => { :foo => 'bar' })
-      read_from_cache('thing/1/{:from=>"path",:params=>{:foo=>"bar"}}').should == result
-    end
-
-    it "should empty the cache when clear_cache is called" do
-      result = Thing.find(1)
-      Thing.clear_cache
-      read_from_cache("thing/1").should == nil
-    end
-
-    it "should not empty the cache of NotTheThing when clear_cache is called on the Thing" do
-      result1 = Thing.find(1)
-      result2 = NotTheThing.find(1)
-      Thing.clear_cache
-      NotTheThing.send(:cache_read, 'notthething/1').should == result2
-    end
-
-    it "should empty all the cache when clear_cache is called on the Thing with :all option set" do
-      result1 = Thing.find(1)
-      result2 = NotTheThing.find(1)
-      Thing.clear_cache(all: true)
-      NotTheThing.send(:cache_read, 'notthething/1').should == nil
-    end
-
-    it "should cache a response with the same persistence" do
-      result1 = Thing.find(1)
-      result1.persisted?.should be true
-      result2 = Thing.find(1)
-      result1.persisted?.should == result2.persisted?
-    end
-
-    it "should read a response when the request is made again" do
-      # make a request
-      Thing.find(1)
-      # make the same request
-      Thing.find(1)
-      # only one request should have happened
-      ActiveResource::HttpMock.requests.length.should == 1
-    end
-
-    it "should read a response when the request is made again for a string primary key" do
-      # make a request
-      Thing.find("fded")
-      # make the same request
-      Thing.find("fded")
-      # only one request should have happened
-      ActiveResource::HttpMock.requests.length.should == 1
-    end
-
-    it "should remake a request when reloaded" do
-      # make a request
-      Thing.find(1)
-      # make the same request, but reload it
-      Thing.find(1, :reload => true)
-      # we should get two requests
-      ActiveResource::HttpMock.requests.length.should == 2
-    end
-
-    it "should remake a request when reloaded for a string primary key" do
-      # make a request
-      Thing.find("fded")
-      # make the same request, but reload it
-      Thing.find("fded", :reload => true)
-      # we should get two requests
-      ActiveResource::HttpMock.requests.length.should == 2
-    end
-
-    it "should rewrite the cache when the request is reloaded" do
-      # make a request
-      Thing.find(1)
-      # get the cached result of the request
-      old_result = read_from_cache("thing/1")
-
-      # change the response
-      ActiveResource::HttpMock.reset!
-      ActiveResource::HttpMock.respond_to do |mock|
-        mock.get "/things/1.json", {}, @other_thing_json
-      end
-
-      Thing.find(1, :reload => true)
-      new_result = read_from_cache("thing/1")
-      # since active resources are equal if and only if they
-      # are the same object or an instance of the same class,
-      # not new?, and have the same id.
-      new_result.name.should_not == old_result.name
-    end
-
-    it "should remake the request when the ttl expires" do
-      # set cache time to live to 1 second
-      Thing.cached_resource.ttl = 1
-      # make a request
-      Thing.find(1)
-      # wait for the cache to expire
-      sleep(1.5)
-      # make the same request
-      Thing.find(1)
-      ActiveResource::HttpMock.requests.length.should == 2
-    end
-
-    it "should not return a frozen object on first request" do
-      result1 = Thing.find(1)
-      result1.should_not be_frozen
-    end
-
-    it "should not return frozen object on a subsequent request" do
-      result1 = Thing.find(1)
-      result2 = Thing.find(1)
-      result2.should_not be_frozen
-    end
-
-    it "should not freeze first requested object on a subsequent request" do
-      result1 = Thing.find(1)
-      result2 = Thing.find(1)
-      result1.should_not be_frozen
-    end
-
-    describe "when ActiveSupport.parse_json_times is enabled" do
-      before(:all) do
-        Time.zone = 'UTC'
-        ActiveSupport.parse_json_times = true
-      end
-
-      it "should convert date times to objects when reading from cache" do
-        Thing.find(4)
-
-        read_from_cache("thing/4").created_at.should == @date_thing[:thing][:created_at]
-      end
-    end
-
-    shared_examples "collection_return_type" do
-      if ActiveResource::VERSION::MAJOR >= 4
-        it "should return an ActiveResource::Collection" do
-          cached = read_from_cache("thing/all")
-          cached.should be_instance_of(ActiveResource::Collection)
-        end
-
-        it "should return a chainable instance of the collection_parser" do
-          Thing.cached_resource.cache.clear
-          class CustomCollection < ActiveResource::Collection; end
-          Thing.collection_parser = CustomCollection
-
-          ActiveResource::HttpMock.respond_to do |mock|
-            mock.get "/things.json?name=ada", {}, @thing_collection.to_json
-            mock.get "/things.json?major=CS&name=ada", {}, @thing_collection2.to_json
-          end
-
-          non_cached = Thing.where(name: 'ada')
-          non_cached.original_params.should == { :name => 'ada' }
-          non_cached.map(&:id).should == @thing_collection.map { |h| h[:id]}
-
-          cached = read_from_cache('thing/all/{:params=>{:name=>"ada"}}')
-          cached.should be_instance_of(CustomCollection)
-          cached.original_params.should == { :name => 'ada' }
-          cached.resource_class.should == Thing
-          cached.map(&:id).should == @thing_collection.map { |h| h[:id]}
-
-          if ActiveResource::VERSION::MAJOR < 5
-            non_cached = cached.resource_class.where(cached.original_params.merge(major: 'CS'))
-          else
-            non_cached = cached.where(major: 'CS')
-          end
-
-          non_cached.original_params.should == { :name => 'ada', :major => 'CS' }
-          non_cached.resource_class.should == Thing
-          non_cached.map(&:id).should == @thing_collection2.map { |h| h[:id]}
-          cached = read_from_cache('thing/all/{:params=>{:name=>"ada",:major=>"cs"}}')
-          cached.original_params.should == { :name => 'ada', :major => 'CS' }
-          cached.resource_class.should == Thing
-          cached.map(&:id).should == @thing_collection2.map { |h| h[:id]}
-        end
-      else
-        it "should return an Array" do
-          cached = read_from_cache("thing/all")
-          cached.should be_instance_of(Array)
-        end
-      end
-    end
-
-    shared_examples "collection_freezing" do
-      it "should not return a frozen collection on first request" do
-        Thing.cached_resource.cache.clear
-        collection1 = Thing.all
-        collection1.should_not be_frozen
-      end
-
-      it "should not return a frozen collection on a subsequent request" do
-        Thing.cached_resource.cache.clear
-        collection1 = Thing.all
-        collection2 = Thing.all
-        collection2.should_not be_frozen
-      end
-
-      it "should not freeze first requested collection on a subsequent request" do
-        Thing.cached_resource.cache.clear
-        result1 = Thing.all
-        result2 = Thing.all
-        result1.should_not be_frozen
-      end
-
-      it "should not return frozen members on first request" do
-        Thing.cached_resource.cache.clear
-        collection1 = Thing.all
-        collection1.first.should_not be_frozen
-      end
-
-      it "should not return frozen members on a subsequent request" do
-        Thing.cached_resource.cache.clear
-        collection1 = Thing.all
-        collection2 = Thing.all
-        collection2.first.should_not be_frozen
-      end
-
-      it "should not freeze members on a subsequent request" do
-        Thing.cached_resource.cache.clear
-        collection1 = Thing.all
-        member1 = Thing.find(1)
-        collection1.first.should_not be_frozen
-      end
-
-    end
-
-    shared_examples "collection_cache_clearing" do
-      it "should empty the cache when clear_cache is called" do
-        Thing.clear_cache
-        read_from_cache("thing/all").should == nil
-        read_from_cache("thing/1").should == nil
-      end
-
-    end
-
-    describe "when collection synchronize is enabled" do
-      before(:each) do
-        Thing.cached_resource.cache.clear
-        Thing.cached_resource.collection_synchronize = true
-
-        ActiveResource::HttpMock.reset!
-        ActiveResource::HttpMock.respond_to do |mock|
-          mock.get "/things/1.json", {}, @thing_json
-          mock.get "/things/fded.json", {}, @string_thing_json
-          mock.get "/things.json", {}, [@thing[:thing], @string_thing[:thing]].to_json(:root => :thing)
-        end
-
-        # make a request for all things
-        Thing.all
-      end
-
-      include_examples "collection_return_type"
-
-      include_examples "collection_freezing"
-
-      it "should write cache entries for its members" do
-        result = Thing.find(1)
-        string_result = Thing.find("fded")
-        # only the all request should have been made
-        ActiveResource::HttpMock.requests.length.should == 1
-        # the result should be cached with the appropriate key
-        read_from_cache("thing/1").should == result
-        read_from_cache("thing/fded").should == string_result
-      end
-
-      include_examples "collection_cache_clearing"
-
-      it "should rewrite cache entries for its members when reloaded" do
-        # get the soon to be stale result so that we have a cache entry
-        old_result = Thing.find(1)
-        old_string_result = Thing.find("fded")
-        # change the server
-        ActiveResource::HttpMock.respond_to do |mock|
-          mock.get "/things/1.json", {}, @other_thing_json
-          mock.get "/things/fded.json", {}, @other_string_thing_json
-          mock.get "/things.json", {}, [@other_thing[:thing], @other_string_thing[:thing]].to_json(:root => :thing)
-        end
-        # reload the collection
-        Thing.all(:reload => true)
-        # get the updated result, read from the cache
-        result = Thing.find(1)
-        read_from_cache("thing/all")[0].should == result
-        read_from_cache("thing/all")[0].name.should == result.name
-        string_result = Thing.find("fded")
-        read_from_cache("thing/all")[1].should == string_result
-        read_from_cache("thing/all")[1].name.should == string_result.name
-      end
-
-      it "should update the collection when an individual request is reloaded" do
-        # change the server
-        ActiveResource::HttpMock.respond_to do |mock|
-          mock.get "/things/1.json", {}, @other_thing_json
-          mock.get "/things/fded.json", {}, @other_string_thing_json
-          mock.get "/things.json", {}, [@other_thing[:thing], @other_string_thing[:thing]].to_json(:root => :thing)
-        end
-
-        # reload the individual
-        result = Thing.find(1, :reload => true)
-        read_from_cache("thing/all")[0].should == result
-        read_from_cache("thing/all")[0].name.should == result.name
-        string_result = Thing.find("fded", :reload => true)
-        read_from_cache("thing/all")[1].should == string_result
-        read_from_cache("thing/all")[1].name.should == string_result.name
-      end
-
-      it "should update both the collection and the member cache entries when a subset of the collection is retrieved" do
-        # create cache entries for 1 and all
-        old_individual = Thing.find(1)
-        old_collection = Thing.all
-
-        # change the server
-        ActiveResource::HttpMock.respond_to do |mock|
-          mock.get "/things.json?name=Ari", {}, [@other_thing[:thing]].to_json(:root => :thing)
-          mock.get "/things.json?name=Lon", {}, [@other_string_thing[:thing]].to_json(:root => :thing)
-        end
-
-        # make a request for a subset of the "mother" collection
-        result = Thing.find(:all, :params => {:name => "Ari"})
-        # the collection should be updated to reflect the server change
-        read_from_cache("thing/all")[0].should == result[0]
-        read_from_cache("thing/all")[0].name.should == result[0].name
-        # the individual should be updated to reflect the server change
-        read_from_cache("thing/1").should == result[0]
-        read_from_cache("thing/1").name.should == result[0].name
-
-        # make a request for a subset of the "mother" collection
-        result = Thing.find(:all, :params => {:name => "Lon"})
-        # the collection should be updated to reflect the server change
-        read_from_cache("thing/all")[1].should == result[0]
-        read_from_cache("thing/all")[1].name.should == result[0].name
-        # the individual should be updated to reflect the server change
-        read_from_cache("thing/fded").should == result[0]
-        read_from_cache("thing/fded").name.should == result[0].name
-      end
-
-      it "should maintain the order of the collection when updating it" do
-        # change the server to return a longer collection
-        ActiveResource::HttpMock.respond_to do |mock|
-          mock.get "/things.json", {}, [@thing[:thing], @thing3[:thing], @thing2[:thing], @string_thing[:thing]].to_json(:root => :thing)
-        end
-
-        # create cache entry for the collection (we reload because in before block we make an all request)
-        old_collection = Thing.all(:reload => true)
-
-        # change the server's response for the thing with id 2
-        ActiveResource::HttpMock.respond_to do |mock|
-          mock.get "/things/2.json", {}, @other_thing2.to_json(:root => :thing)
-          mock.get "/things/fded.json", {}, @other_string_thing.to_json(:root => :thing)
-        end
-
-        # get thing 2, thereby updating the collection
-        result = Thing.find(2, :reload => true)
-        # get the updated collection from the cache
-        updated_collection = Thing.all
-        # name should have changed to "Jeb"
-        updated_collection[2].name.should == result.name
-        # the updated collection should have the elements in the same order
-        old_collection.each_with_index do |thing, i|
-          updated_collection[i].id.should == thing.id
-        end
-
-        # get string thing, thereby updating the collection
-        string_result = Thing.find("fded", :reload => true)
-        # get the updated collection from the cache
-        updated_collection = Thing.all
-        # name should have changed to "Lon"
-        updated_collection[3].name.should == string_result.name
-        # the updated collection should have the elements in the same order
-        old_collection.each_with_index do |thing, i|
-          updated_collection[i].id.should == thing.id
-        end
-      end
-    end
-
-    describe "when collection synchronize is disabled" do
-      before(:each) do
-        Thing.cached_resource.cache.clear
-        Thing.cached_resource.collection_synchronize = false
-
-        ActiveResource::HttpMock.reset!
-        ActiveResource::HttpMock.respond_to do |mock|
-          mock.get "/things/1.json", {}, @thing_json
-          mock.get "/things/fded.json", {}, @string_thing_json
-          mock.get "/things.json", {}, [@thing[:thing], @string_thing[:thing]].to_json(:root => :thing)
-        end
-
-        # make a request for all things
-        Thing.all
-      end
-
-      include_examples "collection_return_type"
-
-      include_examples "collection_freezing"
-
-      it "should not write cache entries for its members" do
-        result = Thing.find(1)
-        result = Thing.find("fded")
-        # both the all in the before each and this request should have been made
-        ActiveResource::HttpMock.requests.length.should == 3
-      end
-
-      include_examples "collection_cache_clearing"
-
-      it "should not update the collection when an individual request is reloaded" do
-        # change the server
-        ActiveResource::HttpMock.respond_to do |mock|
-          mock.get "/things/1.json", {}, @other_thing_json
-          mock.get "/things/fded.json", {}, @other_string_thing_json
-          mock.get "/things.json", {}, [@other_thing[:thing], @other_string_thing[:thing]].to_json(:root => :thing)
-        end
-
-        # reload the individual
-        result = Thing.find(1, :reload => true)
-        # the ids are the same, but the names should be different
-        read_from_cache("thing/all")[0].name.should_not == result.name
-
-        # reload the individual
-        string_result = Thing.find("fded", :reload => true)
-        # the ids are the same, but the names should be different
-        read_from_cache("thing/all")[1].name.should_not == string_result.name
-      end
-    end
-
-    describe "when ttl randomization is enabled" do
-      before(:each) do
-        @ttl = 1
-        Thing.cached_resource.ttl = @ttl
-        Thing.cached_resource.ttl_randomization = true
-        Thing.cached_resource.send(:sample_range, 1..2, @ttl)
-        # next ttl 1.72032449344216
-      end
-
-      it "should generate a random ttl" do
-        Thing.cached_resource.cache.should_receive(:write)
-        Thing.cached_resource.cache.stub(:write) do |key, value, options|
-          # we know the ttl should not be the same as the set ttl
-          options[:expires_in].should_not == @ttl
-        end
-
-        Thing.find(1)
-      end
-
-    end
-  end
-
-  describe "when disabled" do
-    before(:each) do
-      Thing.cached_resource.cache.clear
-      Thing.cached_resource.off!
-
-      ActiveResource::HttpMock.reset!
-      ActiveResource::HttpMock.respond_to do |mock|
-        mock.get "/things/1.json", {}, @thing_json
-        mock.get "/things/fded.json", {}, @string_thing_json
-      end
-    end
-
-    it "should not cache a response" do
-      result = Thing.find(1)
-      read_from_cache("thing/1").should be_nil
-    end
-
-    it "should always remake the request" do
-      Thing.find(1)
-      ActiveResource::HttpMock.requests.length.should == 1
-      Thing.find(1)
-      ActiveResource::HttpMock.requests.length.should == 2
-    end
-
-    it "should always remake the request for a string primary key" do
-      Thing.find("fded")
-      ActiveResource::HttpMock.requests.length.should == 1
-      Thing.find("fded")
-      ActiveResource::HttpMock.requests.length.should == 2
-    end
-  end
-
-  describe "when cache_collections is disabled" do
-    before(:each) do
-      Thing.cached_resource.cache.clear
-      Thing.cached_resource.cache_collections = false
-
-      ActiveResource::HttpMock.reset!
-      ActiveResource::HttpMock.respond_to do |mock|
-        mock.get "/things.json", {}, [@thing[:thing],@string_thing[:thing]].to_json(:root => :thing)
-        mock.get "/things/1.json", {}, @thing_json
-        mock.get "/things/fded.json", {}, @string_thing_json
-      end
-    end
-
-    it "should cache a response" do
-      result = Thing.find(1)
-      read_from_cache("thing/1").should == result
-    end
-
-    it "should not remake a single request" do
-      result = Thing.find(1)
-      ActiveResource::HttpMock.requests.length.should == 1
-      result = Thing.find(1)
-      ActiveResource::HttpMock.requests.length.should == 1
-    end
-
-    it "should always remake the request for collections" do
-      Thing.all
-      ActiveResource::HttpMock.requests.length.should == 1
-      Thing.all
-      ActiveResource::HttpMock.requests.length.should == 2
-    end
-  end
-end