arid_cache 1.2.0 → 1.3.0

data/spec/arid_cache/cache_proxy/result_processor_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+describe AridCache::CacheProxy::ResultProcessor do
+
+  def new_result(value, opts={})
+    AridCache::CacheProxy::ResultProcessor.new(value, opts)
+  end
+
+  describe "empty array" do
+    before :each do
+      @result = new_result([])
+    end
+
+    it "should recognize an empty array" do
+      @result.is_enumerable?.should be_true
+      @result.is_empty?.should be_true
+      @result.is_activerecord?.should be_false
+      @result.is_hashes?.should be_false
+      @result.is_cached_result?.should be_false
+      @result.order_in_database?.should be_false
+      @result.to_cache.should be_a(AridCache::CacheProxy::CachedResult)
+    end
+  end
+
+  describe "basic array" do
+    before :each do
+      @result = new_result([1,2,3])
+    end
+
+    it "should recognize an empty array" do
+      @result.is_enumerable?.should be_true
+      @result.is_empty?.should be_false
+      @result.is_activerecord?.should be_false
+      @result.is_hashes?.should be_false
+      @result.is_activerecord_reflection?.should be_false
+      @result.order_in_database?.should be_false
+      @result.to_cache.should == [1,2,3]
+    end
+  end
+
+  describe "array of activerecords" do
+    before :each do
+      @company = Company.make
+      @result = new_result([@company])
+    end
+
+    it "should recognize activerecords" do
+      @result.is_enumerable?.should be_true
+      @result.is_empty?.should be_false
+      @result.is_activerecord?.should be_true
+      @result.is_hashes?.should be_false
+      @result.order_in_database?.should be_false
+      @result.is_activerecord_reflection?.should be_false
+    end
+
+    it "should convert to a CachedResult" do
+      @cached = @result.to_cache
+      @cached.should be_a(AridCache::CacheProxy::CachedResult)
+      @cached.ids.should == [@company.id]
+      @cached.klass.should == @company.class
+      @cached.count.should == 1
+    end
+  end
+
+  describe "array of hashes" do
+    before :each do
+      @result = new_result([{}, {}])
+    end
+
+    it "should be recognized" do
+      @result.is_enumerable?.should be_true
+      @result.is_empty?.should be_false
+      @result.is_activerecord?.should be_false
+      @result.is_hashes?.should be_true
+      @result.order_in_database?.should be_false
+      @cached = @result.to_cache
+      @cached.should == [{}, {}]
+    end
+  end
+
+  describe "proxy reflections" do
+    before :each do
+      @user = User.make
+    end
+
+    it "should be recognized" do
+      @result = new_result(@user.companies)
+      @result.is_activerecord_reflection?.should be_true
+    end
+
+    it "should recognize named scope" do
+      @result = new_result(User.companies)
+      @result.is_activerecord_reflection?.should be_true
+    end
+  end
+
+  describe "cached result" do
+    before :each do
+      @result = new_result(AridCache::CacheProxy::CachedResult.new)
+    end
+
+    it "should be recognized" do
+      @result.is_cached_result?.should be_true
+    end
+  end
+
+  describe "order in database" do
+    before :each do
+      @company = Company.make
+      @cached = AridCache::CacheProxy::CachedResult.new
+      @cached.klass = Company
+      @cached.ids = [@company.id]
+    end
+
+    it "cached results should use the database for ordering" do
+      @result = new_result(@cached, :order => 'column DESC')
+      @result.is_cached_result?.should be_true
+      @result.order_in_database?.should be_true
+    end
+
+    it "active records should use the database only if an order is specified" do
+      @result = new_result([@company], :order => 'column DESC')
+      @result.order_in_database?.should be_true
+      @result = new_result([@company], :order => :symbol)
+      @result.order_in_database?.should be_true
+      @result = new_result([@company], :order => Proc.new {})
+      @result.order_in_database?.should be_false
+    end
+  end
+
+
+  describe "non-activerecord enumerables" do
+    before :each do
+      @value = (1..10).to_a
+    end
+
+    it "should return it unmodified" do
+      new_result(@value).to_result.should == @value
+    end
+
+    it "should apply limit" do
+      @limit = 3
+      new_result(@value, :limit => @limit).to_result.should == @value[0,@limit]
+      new_result(@value, :limit => @limit).to_result.size.should == @limit
+      new_result(@value, :limit => @value.size).to_result.should == @value
+      new_result(@value, :limit => 0).to_result.should == []
+    end
+
+    it "should apply offset" do
+      @offset = 3
+      new_result(@value, :offset => @offset).to_result.should == @value[@offset,@value.size]
+      new_result(@value, :offset => @offset).to_result.size.should == @value.size - @offset
+      new_result(@value, :offset => @value.size).to_result.should == []
+    end
+
+    it "should apply offset and limit" do
+      @offset = 2
+      @limit = 3
+      new_result(@value, :offset => @offset, :limit => @limit).to_result.should == @value[@offset,@limit]
+      new_result(@value, :offset => @offset, :limit => @limit).to_result.size.should == @limit
+    end
+
+    describe "order by" do
+      before :each do
+        @low = [1, 2, 3, 4]
+        @high = [5, 6, 7, 8]
+        @hashes = [{ 'low' => 4, :high => 6 }, { 'low' => 3, :high => 5 }, { 'low' => 1, :high => 8 }, { 'low' => 2, :high => 7 }]
+        @value = (1..10).to_a
+      end
+
+      it "should order by proc" do
+        new_result(@value, :order => Proc.new { |a, b| b <=> a }).to_result.should == @value.reverse
+      end
+
+      it "should order hashes by string key" do
+        new_result(@hashes, :order => 'low').to_result.collect { |h| h['low'] }.should == @low
+      end
+
+      it "should order hashes by symbol key" do
+        new_result(@hashes, :order => :high).to_result.collect { |h| h[:high] }.should == @high
+      end
+    end 
+    
+    describe "paginating arrays" do
+      before :each do
+        @value = (1..10).to_a
+      end
+
+      it "should paginate" do
+        @result = new_result(@value, :page => 1).to_result
+        @result.should be_a(WillPaginate::Collection)
+        @result.total_entries.should == @value.size
+        @result.current_page.should == 1
+      end                          
+      
+      it "should handle per_page option" do
+        @result = new_result(@value, :page => 3, :per_page => 3).to_result
+        @result.should be_a(WillPaginate::Collection)
+        @result.total_entries.should == @value.size
+        @result.current_page.should == 3
+        @result.per_page.should == 3        
+      end
+    end
+    
+    it "should order limit and then paginate all at once" do     
+       # It will reverse it, offset 2, limit 15, then paginate
+       @options = {
+         :limit => 15, 
+         :offset => 2, 
+         :order => Proc.new { |a, b| b <=> a },
+         :page => 2, 
+         :per_page => 5
+       }
+       @result = new_result((1..20).to_a, @options).to_result.should == [13, 12, 11, 10, 9]
+    end
+  end
+end

data/spec/arid_cache/cache_proxy_spec.rb

@@ -1,95 +1,124 @@
 require 'spec_helper'
 
 describe AridCache::CacheProxy do
-  describe 'preserve_order' do
+  # describe 'preserve_order' do
+  #   before :each do
+  #     @proxy = AridCache::CacheProxy.new(Company, 'dummy-key', {})
+  #   end
+  # 
+  #   it "id column should be prefixed by the table name" do
+  #     ::ActiveRecord::Base.stubs(:is_mysql_adapter?).returns(true)
+  #     @proxy.send(:preserve_order, [1,2,3]).should =~ %r[#{Company.table_name}]
+  #   end
+  # 
+  #   it "id column should be prefixed by the table name" do
+  #     ::ActiveRecord::Base.stubs(:is_mysql_adapter?).returns(false)
+  #     @proxy.send(:preserve_order, [1,2,3]).should =~ %r[#{Company.table_name}]
+  #   end
+  # end
+  # 
+  # describe "with raw => true" do
+  #   before :each do
+  #     @user = User.make
+  #     @user.companies << Company.make
+  #     @user.companies << Company.make
+  #     @user.clear_instance_caches
+  #   end
+  # 
+  #   it "should return a CacheProxy::CachedResult" do
+  #     @user.cached_companies(:raw => true).should be_a(AridCache::CacheProxy::CachedResult)
+  #   end
+  # 
+  #   it "result should have the same ids as the normal result" do
+  #     @user.cached_companies(:raw => true).ids.should == @user.cached_companies.collect(&:id)
+  #   end
+  # 
+  #   it "should ignore :raw => false" do
+  #     @user.cached_companies(:raw => false).should == @user.cached_companies
+  #   end
+  # 
+  #   it "should only query once to seed the cache, ignoring all other options" do
+  #     lambda { @user.cached_companies(:raw => true, :limit => 0, :order => 'nonexistent_column desc') }.should query(1)
+  #   end
+  # 
+  #   it "should ignore all other options if the cache has already been seeded" do
+  #     lambda {
+  #       companies = @user.cached_companies
+  #       @user.cached_companies(:raw => true, :limit => 0, :order => 'nonexistent_column').ids.should == companies.collect(&:id)
+  #     }.should query(1)
+  #   end
+  # 
+  #   it "should not use the raw option when reading from the cache" do
+  #     Rails.cache.expects(:read).with(@user.arid_cache_key(:companies), {})
+  #     @user.cached_companies(:raw => true)
+  #   end
+  # 
+  #   it "should work for calls to a method that ends with _count" do
+  #     @user.cached_bogus_count do
+  #       10
+  #     end
+  #     @user.cached_bogus_count(:raw => true).should == 10
+  #   end
+  # 
+  #   it "should work for calls to a method that ends with _count" do
+  #     @user.cached_companies_count(:raw => true).should == @user.cached_companies_count
+  #   end
+  # end
+  # 
+  # describe "with clear => true" do
+  #   before :each do
+  #     @user = User.make
+  #     @user.companies << Company.make
+  #     @user.companies << Company.make
+  #     @user.clear_instance_caches rescue Rails.cache.clear
+  #   end
+  # 
+  #   it "should not fail if there is no cached value" do
+  #     lambda { @user.cached_companies(:clear => true) }.should_not raise_exception
+  #   end
+  # 
+  #   it "should clear the cached entry" do
+  #     key = @user.arid_cache_key(:companies)
+  #     @user.cached_companies
+  #     Rails.cache.read(key).should_not be_nil
+  #     @user.cached_companies(:clear => true)
+  #     Rails.cache.read(key).should be_nil
+  #   end
+  # 
+  #   it "should not read from the cache or database" do
+  #     Rails.cache.expects(:read).never
+  #     lambda {
+  #       @user.cached_companies(:clear => true)
+  #     }.should query(0)
+  #   end
+  # end
+  
+  describe "arrays" do
     before :each do
-      @proxy = AridCache::CacheProxy.new(Company, 'dummy-key', {})
-    end
-
-    it "id column should be prefixed by the table name" do
-      ::ActiveRecord::Base.stubs(:is_mysql_adapter?).returns(true)
-      @proxy.send(:preserve_order, [1,2,3]).should =~ %r[#{Company.table_name}]
-    end
-
-    it "id column should be prefixed by the table name" do
-      ::ActiveRecord::Base.stubs(:is_mysql_adapter?).returns(false)
-      @proxy.send(:preserve_order, [1,2,3]).should =~ %r[#{Company.table_name}]
-    end
-  end
-
-  describe "with raw => true" do
-    before :each do
-      @user = User.make
-      @user.companies << Company.make
-      @user.companies << Company.make
-      @user.clear_instance_caches
-    end
-
-    it "should return a CacheProxy::Result" do
-      @user.cached_companies(:raw => true).should be_a(AridCache::CacheProxy::Result)
-    end
-
-    it "result should have the same ids as the normal result" do
-      @user.cached_companies(:raw => true).ids.should == @user.cached_companies.collect(&:id)
-    end
-
-    it "should ignore :raw => false" do
-      @user.cached_companies(:raw => false).should == @user.cached_companies
-    end
-
-    it "should only query once to seed the cache, ignoring all other options" do
-      lambda { @user.cached_companies(:raw => true, :limit => 0, :order => 'nonexistent_column desc') }.should query(1)
-    end
-
-    it "should ignore all other options if the cache has already been seeded" do
-      lambda {
-        companies = @user.cached_companies
-        @user.cached_companies(:raw => true, :limit => 0, :order => 'nonexistent_column').ids.should == companies.collect(&:id)
-      }.should query(1)
-    end
-
-    it "should not use the raw option when reading from the cache" do
-      Rails.cache.expects(:read).with(@user.arid_cache_key(:companies), {})
-      @user.cached_companies(:raw => true)
-    end
-
-    it "should work for calls to a method that ends with _count" do
-      @user.cached_bogus_count do
-        10
-      end
-      @user.cached_bogus_count(:raw => true).should == 10
-    end
-
-    it "should work for calls to a method that ends with _count" do
-      @user.cached_companies_count(:raw => true).should == @user.cached_companies_count
-    end
-  end
-
-  describe "with clear => true" do
-    before :each do
-      @user = User.make
-      @user.companies << Company.make
-      @user.companies << Company.make
-      @user.clear_instance_caches rescue Rails.cache.clear
-    end
-
-    it "should not fail if there is no cached value" do
-      lambda { @user.cached_companies(:clear => true) }.should_not raise_exception
-    end
-
-    it "should clear the cached entry" do
-      key = @user.arid_cache_key(:companies)
-      @user.cached_companies
-      Rails.cache.read(key).should_not be_nil
-      @user.cached_companies(:clear => true)
-      Rails.cache.read(key).should be_nil
-    end
-
-    it "should not read from the cache or database" do
-      Rails.cache.expects(:read).never
-      lambda {
-        @user.cached_companies(:clear => true)
-      }.should query(0)
-    end
+      @o = Class.new do
+        include AridCache
+        def result
+          @result ||= (1..5).to_a
+        end
+      end.new
+    end
+
+    # it "should cache the result" do
+    #   @o.cached_result { result }.should == @o.result 
+    # end
+    # 
+    # it "should respect the :limit option" do
+    #   @o.cached_result(:limit => 4) { result }.should == [1,2,3,4]
+    # end
+
+    it "should respect the :offset option" do
+      @o.cached_result(:offset => 2) { result }.should == [3,4,5]
+    end
+  
+    # it "should apply pagination" do
+    #   result = @o.cached_result(:page => 2, :per_page => 2) { result }
+    #   result.should == @o.paginate(:page => 2, :per_page => 2)
+    #   result.total_entries.should == @o.result.size
+    # end
   end
 end

data/test/console

@@ -1,3 +1,5 @@
+#!/usr/bin/ruby
+
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
 
 require 'rubygems'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: arid_cache
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 27
   prerelease: 
   segments: 
   - 1
-  - 2
+  - 3
   - 0
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Karl Varga
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-28 00:00:00 -07:00
+date: 2011-04-05 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -98,6 +98,9 @@ files:
 - lib/arid_cache.rb
 - lib/arid_cache/active_record.rb
 - lib/arid_cache/cache_proxy.rb
+- lib/arid_cache/cache_proxy/options.rb
+- lib/arid_cache/cache_proxy/result_processor.rb
+- lib/arid_cache/cache_proxy/utilities.rb
 - lib/arid_cache/helpers.rb
 - lib/arid_cache/inflector.rb
 - lib/arid_cache/inflector/inflections.rb
@@ -106,7 +109,9 @@ files:
 - rails/init.rb
 - spec/arid_cache/active_record_spec.rb
 - spec/arid_cache/arid_cache_spec.rb
-- spec/arid_cache/cache_proxy_result_spec.rb
+- spec/arid_cache/cache_proxy/cached_result_spec.rb
+- spec/arid_cache/cache_proxy/options_spec.rb
+- spec/arid_cache/cache_proxy/result_processor_spec.rb
 - spec/arid_cache/cache_proxy_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -162,7 +167,9 @@ summary: Automates efficient caching of your ActiveRecord collections, gives you
 test_files: 
 - spec/arid_cache/active_record_spec.rb
 - spec/arid_cache/arid_cache_spec.rb
-- spec/arid_cache/cache_proxy_result_spec.rb
+- spec/arid_cache/cache_proxy/cached_result_spec.rb
+- spec/arid_cache/cache_proxy/options_spec.rb
+- spec/arid_cache/cache_proxy/result_processor_spec.rb
 - spec/arid_cache/cache_proxy_spec.rb
 - spec/spec_helper.rb
 - spec/support/ar_query.rb