onyx-cache-money 0.2.5.8 → 0.2.6

data/config/environment.rb

@@ -1,6 +1,11 @@
 require 'activerecord'
 
 ActiveRecord::Base.establish_connection(
-  :adapter => 'sqlite3',
-  :dbfile => ':memory:'
+  # :adapter => 'sqlite3',
+  # :dbfile => ':memory:'
+
+  :adapter => 'mysql',
+  :socket =>  %w[/tmp/mysql.sock /var/lib/mysql/mysql.sock /var/run/mysqld/mysqld.sock /opt/local/var/run/mysql5/mysqld.sock].detect { |f| File.exists? f },
+  :database => 'cache_money_development',
+  :username => 'root'  
 )

data/lib/cash/accessor.rb

@@ -8,14 +8,20 @@ module Cash
     end
 
     module ClassMethods
+      NIL_CACHE_VALUE = 'NIL_CACHE_VALUE'
+      
       def fetch(keys, options = {}, &block)
         case keys
         when Array
-          keys = keys.collect { |key| cache_key(key) }
-          hits = repository.get_multi(keys)
-          if (missed_keys = keys - hits.keys).any?
-            missed_values = block.call(missed_keys)
-            hits.merge!(missed_keys.zip(Array(missed_values)).to_hash)
+          cache_and_actual_keys = keys.inject({}) { |memo, key| memo[cache_key(key)] = key; memo }
+          cache_keys = keys.collect {|key| cache_key(key)}
+          
+          hits = repository.get_multi(cache_keys)
+          if (missed_cache_keys = cache_keys - hits.keys).any?
+            actual_missed_keys = missed_cache_keys.collect {|missed_cache_key| cache_and_actual_keys[missed_cache_key]}
+            misses = block.call(actual_missed_keys)
+
+            hits.merge!(misses)
           end
           hits
         else
@@ -26,17 +32,25 @@ module Cash
       def get(keys, options = {}, &block)
         case keys
         when Array
-          fetch(keys, options, &block)
+          results = fetch(keys, options) do |missed_keys|
+            results = yield(missed_keys)
+            results.each {|key, value| add(key, wrap_nil(value), options)}
+            results
+          end
+          results.each { |key, result| results[key] = unwrap_nil(result) }
         else
-          fetch(keys, options) do
+          result = fetch(keys, options) do
             if block_given?
-              add(keys, result = yield(keys), options)
+              result = yield(keys)
+              value = result.is_a?(Hash) ? result[cache_key(keys)] : result
+              add(keys, wrap_nil(value), options)
               result
             end
           end
+          unwrap_nil(result)
         end
       end
-
+      
       def add(key, value, options = {})
         if repository.add(cache_key(key), value, options[:ttl] || 0, options[:raw]) == "NOT_STORED\r\n"
           yield if block_given?
@@ -66,8 +80,20 @@ module Cash
       end
 
       def cache_key(key)
-        "#{name}:#{cache_config.version}/#{key.to_s.gsub(' ', '+')}"
+        ready = key =~ /#{name}:#{cache_config.version}/
+        ready ? key : "#{name}:#{cache_config.version}/#{key.to_s.gsub(' ', '+')}"
+      end
+      
+      private
+      
+      def wrap_nil(value)
+        value.nil? ? NIL_CACHE_VALUE : value
       end
+
+      def unwrap_nil(value)
+        value == NIL_CACHE_VALUE ? nil : value
+      end
+
     end
 
     module InstanceMethods

data/lib/cash/finders.rb

@@ -10,7 +10,7 @@ module Cash
       def self.extended(active_record_class)
         class << active_record_class
           alias_method_chain :find_every, :cache
-          alias_method_chain :find_from_ids, :cache
+          # alias_method_chain :find_from_ids, :cache
           alias_method_chain :calculate, :cache
         end
       end
@@ -25,9 +25,9 @@ module Cash
       end
 
       # User.find(1), User.find(1, 2, 3), User.find([1, 2, 3]), User.find([])
-      def find_from_ids_with_cache(ids, options)
-        Query::PrimaryKey.perform(self, ids, options, scope(:find))
-      end
+      # def find_from_ids_with_cache(ids, options)
+      #   Query::PrimaryKey.perform(self, ids, options, scope(:find))
+      # end
 
       # User.count(:all), User.count, User.sum(...)
       def calculate_with_cache(operation, column_name, options = {})

data/lib/cash/index.rb

@@ -67,6 +67,11 @@ module Cash
     end
     include Attributes
 
+    #not ideal, need to find a better solution
+    def serialize_objects(objects)
+      primary_key? ? objects.first : objects.map(&:id)
+    end
+
     def serialize_object(object)
       primary_key? ? object : object.id
     end

data/lib/cash/query/abstract.rb

@@ -1,7 +1,8 @@
 module Cash
   module Query
     class Abstract
-      delegate :with_exclusive_scope, :get, :table_name, :indices, :find_from_ids_without_cache, :cache_key, :columns_hash, :to => :@active_record
+      delegate :with_exclusive_scope, :get, :quoted_table_name, :connection, :indices, 
+        :find_every_without_cache, :cache_key, :columns_hash, :quote_value, :to => :@active_record
 
       def self.perform(*args)
         new(*args).perform
@@ -49,9 +50,12 @@ module Cash
 
       private
       def cacheable?(*optionss)
+        # Cache money used to cache queries with order option only when order was "id asc";
+        #   For now, we just want all order queries to go to the database always.
+        return if optionss.find {|options| options[:order] }
         optionss.each { |options| return unless safe_options_for_cache?(options) }
         partial_indices = optionss.collect { |options| attribute_value_pairs_for_conditions(options[:conditions]) }
-        return if partial_indices.include?(nil)
+        return if partial_indices.flatten.include?(nil)
         attribute_value_pairs = partial_indices.sum.sort { |x, y| x[0] <=> y[0] }
         if index = indexed_on?(attribute_value_pairs.collect { |pair| pair[0] })
           if index.matches?(self)
@@ -70,7 +74,20 @@ module Cash
       end
 
       def cache_keys(attribute_value_pairs)
-        attribute_value_pairs.flatten.join('/')
+        cache_keys = collect_cache_keys(attribute_value_pairs)
+        cache_keys.size == 1 ? cache_keys.first : cache_keys
+      end
+      
+      def collect_cache_keys(pairs)
+        return [] if pairs.empty?
+        key, values = pairs.shift
+        Array(values).inject([]) do |memo,value|
+          partial_keys = collect_cache_keys(pairs.clone)
+
+          memo << "#{key}/#{value}" if partial_keys.empty?
+          partial_keys.each { |partial_key| memo << "#{key}/#{value}/#{partial_key}" }
+          memo
+        end
       end
 
       def safe_options_for_cache?(options)
@@ -81,8 +98,6 @@ module Cash
       def attribute_value_pairs_for_conditions(conditions)
         case conditions
         when Hash
-          # avoid key too long error when passing in array of ids
-          return nil if conditions.values.any? {|value| value.is_a?(Array)}
           conditions.to_a.collect { |key, value| [key.to_s, value] }
         when String
           parse_indices_from_condition(conditions)
@@ -97,17 +112,20 @@ module Cash
 
       AND = /\s+AND\s+/i
       TABLE_AND_COLUMN = /(?:(?:`|")?(\w+)(?:`|")?\.)?(?:`|")?(\w+)(?:`|")?/              # Matches: `users`.id, `users`.`id`, users.id, id
-      VALUE = /'?(\d+|\?|(?:(?:[^']|'')*))'?/                     # Matches: 123, ?, '123', '12''3'
-      KEY_EQ_VALUE = /^\(?#{TABLE_AND_COLUMN}\s+=\s+#{VALUE}\)?$/ # Matches: KEY = VALUE, (KEY = VALUE)
-      ORDER = /^#{TABLE_AND_COLUMN}\s*(ASC|DESC)?$/i              # Matches: COLUMN ASC, COLUMN DESC, COLUMN
+      VALUE = /'?(\d+|\?|(?:(?:[^']|'')*?))'?/                                            # Matches: 123, ?, '123', '12 ''3'
+      KEY_EQ_VALUE = /^\(?#{TABLE_AND_COLUMN}\s+(?:=|IN)\s+\(?(?:#{VALUE})\)?\)?$/      # Matches: KEY = VALUE, (KEY = VALUE), KEY IN (VALUE,VALUE,..)
+      ORDER = /^#{TABLE_AND_COLUMN}\s*(ASC|DESC)?$/i                                      # Matches: COLUMN ASC, COLUMN DESC, COLUMN
 
       def parse_indices_from_condition(conditions = '', *values)
         values = values.dup
         conditions.split(AND).inject([]) do |indices, condition|
-          matched, table_name, column_name, sql_value = *(KEY_EQ_VALUE.match(condition))
+          matched, table_name, column_name, sql_values = *(KEY_EQ_VALUE.match(condition))
           if matched
-            value = sql_value == '?' ? values.shift : columns_hash[column_name].type_cast(sql_value)
-            indices << [column_name, value]
+            actual_values = sql_values.split(',').collect do |sql_value|
+              sql_value == '?' ? values.shift : columns_hash[column_name].type_cast(sql_value)
+            end
+            actual_values.flatten!
+            indices << [column_name, actual_values]
           else
             return nil
           end
@@ -120,8 +138,7 @@ module Cash
       alias_method :index_for, :indexed_on?
 
       def format_results(cache_keys, objects)
-        return objects if objects.blank?
-
+        return [] if objects.blank?
         objects = convert_to_array(cache_keys, objects)
         objects = apply_limits_and_offsets(objects, @options1)
         deserialize_objects(objects)
@@ -131,8 +148,10 @@ module Cash
         missed_keys == cache_keys ? misses : objects
       end
 
-      def serialize_objects(index, objects)
-        Array(objects).collect { |missed| index.serialize_object(missed) }
+      def serialize_objects(index, objects_hash)
+        objects_hash.each do |key, objects|
+          objects_hash[key] = index.serialize_objects(objects)
+        end
       end
 
       def convert_to_array(cache_keys, object)
@@ -152,15 +171,70 @@ module Cash
           objects
         else
           cache_keys = objects.collect { |id| "id/#{id}" }
-          objects = get(cache_keys, &method(:find_from_keys))
+          objects = get(cache_keys) {|missed_keys| find_from_keys(missed_keys)}
           convert_to_array(cache_keys, objects)
         end
       end
 
-      def find_from_keys(*missing_keys)
-        missing_ids = Array(missing_keys).flatten.collect { |key| key.split('/')[2].to_i }
-        find_from_ids_without_cache(missing_ids, {})
+      def find_from_keys(missing_keys, options = {})
+        #[[id/1/title/foo], [id/1/title/foo]]
+        missing_keys_values_pairs = Array(missing_keys).flatten.collect { |key| key.split('/') }
+        #[[id,1,title,foo], [id,2,title,foo]]
+
+        conditions = conditions_from_missing_keys_values_pairs(missing_keys_values_pairs)
+        results = find_every_without_cache options.merge(:conditions => conditions)
+        # [<object1>, <object2>, <object3>]
+
+        collect_results_into_hash(missing_keys_values_pairs, Array(results))
+        #{ id/1/title/foo => [<object1>], id/2/title/foo => [<object2>,<object3>] }
+      end
+      
+      def collect_results_into_hash(missing_keys_values_pairs, results)
+        missing_keys_values_pairs.inject({}) do |memo, missing_keys_values_pair|
+          match = results.select do |result|
+            found_match = false
+            missing_keys_values_pair.each_slice(2) do |key, value|
+              found_match = upcase_if_possible(result.send(key)) == convert_value(key, value)
+              break unless found_match
+            end
+            found_match
+          end
+          memo[cache_key(missing_keys_values_pair.join('/'))] = match
+          memo
+        end
+      end
+      
+      def conditions_from_missing_keys_values_pairs(missing_keys_values_pairs)
+        keys_values = missing_keys_values_pairs.inject({}) do |memo, missing_keys_values_pair|
+          missing_keys_values_pair.each_slice(2) do |key, value|
+            memo[key] ||= []
+            memo[key] << value
+          end
+          memo
+        end
+        # { :id => [1,2], :title => [foo] }
+
+        conditions = keys_values.collect do |key,values|
+          quoted_values = values.collect {|value| quote_value(value, columns_hash[key])}
+          quoted_table_and_column_name = "#{quoted_table_name}.#{connection.quote_column_name(key)}"
+          if quoted_values.size == 1
+            "#{quoted_table_and_column_name} = #{quoted_values}"
+          else
+            "#{quoted_table_and_column_name} IN (#{quoted_values.join(',')})"
+          end
+        end.join(' AND ')
+      end
+      
+      protected 
+      
+      def upcase_if_possible(value)
+        value.respond_to?(:upcase) ? value.upcase : value
+      end
+      
+      def convert_value(key, value)
+        columns_hash[key].type == :integer ? value.to_i : upcase_if_possible(value)
       end
+      
     end
   end
 end

data/lib/cash/query/select.rb

@@ -4,8 +4,9 @@ module Cash
       delegate :find_every_without_cache, :to => :@active_record
 
       protected
-      def miss(_, miss_options)
-        find_every_without_cache(miss_options)
+      def miss(missed_keys, miss_options)
+        # find_every_without_cache(miss_options)
+        misses = find_from_keys(missed_keys, miss_options)
       end
 
       def uncacheable

data/spec/cash/accessor_spec.rb

@@ -21,17 +21,28 @@ module Cash
       describe '#fetch([...])', :shared => true do
         describe 'when there is a total cache miss' do
           it 'yields the keys to the block' do
-            Story.fetch(["yabba", "dabba"]) { |*missing_ids| ["doo", "doo"] }.should == {
-              "Story:1/yabba" => "doo",
+            Story.fetch(["yabba", "dabba"]) do |*missing_ids|
+              {"Story:1/yabba" => "doo", "Story:1/dabba" => "doo"}
+            end.should == {
+              "Story:1/yabba" => "doo", "Story:1/dabba" => "doo"}
+          end
+        end
+
+        describe 'when there is a partial cache miss' do
+          it 'yields just the missing keys and ids to the block' do
+            Story.set("yabba", "dabba")
+            Story.fetch(["yabba", "dabba"]) { |*missing_ids| {"Story:1/dabba" => "doo"} }.should == {
+              "Story:1/yabba" => "dabba",
               "Story:1/dabba" => "doo"
             }
           end
         end
 
-        describe 'when there is a partial cache miss' do
-          it 'yields just the missing ids to the block' do
+        describe 'when there is a total cache hit' do
+          it 'yields empty hash to the block' do
             Story.set("yabba", "dabba")
-            Story.fetch(["yabba", "dabba"]) { |*missing_ids| "doo" }.should == {
+            Story.set("dabba", "doo")
+            Story.fetch(["yabba", "dabba"]) { |*missing_ids| {} }.should == {
               "Story:1/yabba" => "dabba",
               "Story:1/dabba" => "doo"
             }

data/spec/cash/active_record_spec.rb

@@ -41,6 +41,14 @@ module Cash
               it 'raises an error' do
                 lambda { Story.find(1) }.should raise_error(ActiveRecord::RecordNotFound)
               end
+
+              it 'raises an error the second time as well' do
+                begin
+                  Story.find(1)
+                rescue ActiveRecord::RecordNotFound
+                  lambda { Story.find(1) }.should raise_error(ActiveRecord::RecordNotFound)
+                end
+              end            
             end
 
             describe 'when given multiple nonexistent ids' do

data/spec/cash/finders_spec.rb

@@ -5,6 +5,52 @@ module Cash
     describe 'Cache Usage' do
       describe 'when the cache is populated' do
         describe '#find' do
+          
+          describe 'storing nil values in cache' do
+            it 'populates the cache with special token when id does not exist in the database' do
+              Story.find_by_id(999_999)
+              Story.fetch("id/999999").should == 'NIL_CACHE_VALUE'
+            end
+
+            it 'caches the non-existent record' do
+              Story.find_by_id(999_999)
+              mock(Story.connection).execute.never
+              Story.find_by_id(999_999)
+            end
+
+            it 'correctly retrieves nil when special token is stored in the cache' do
+              Story.find_by_id(999_999)
+              Story.find_by_id(999_999).should be_nil
+            end
+            
+            it 'populates the cache with multiple special tokens when none of the ids exist' do
+              Story.find(:all, :conditions => {:id => [999_997, 999_998]} )
+              Story.fetch("id/999997").should == 'NIL_CACHE_VALUE'
+              Story.fetch("id/999998").should == 'NIL_CACHE_VALUE'
+            end
+
+            it 'caches the non-existent records when finding by multiple ids' do
+              Story.find(:all, :conditions => {:id => [999_997, 999_998]} )
+              mock(Story.connection).execute.never
+              Story.find(:all, :conditions => {:id => [999_997, 999_998]} )
+            end
+
+            it 'correctly retrieves empty array when special tokens are stored in the cache' do
+              Story.find(:all, :conditions => {:id => [999_997, 999_998]} )
+              Story.find(:all, :conditions => {:id => [999_997, 999_998]} ).should == []
+            end
+
+            it "populates the cache correctly when passing in a nonexistent key" do
+              story1 = Story.create!
+              story2 = Story.create!
+              $memcache.flush_all
+              Story.find(:all, :conditions => ["id IN (?)", [story1.id, 999, story2.id]]).should == [story1, story2]
+              Story.fetch("id/#{story1.id}").should == story1
+              Story.fetch("id/#{story2.id}").should == story2
+              Story.fetch("id/999").should == 'NIL_CACHE_VALUE'
+            end          
+          end
+          
           describe '#find(1)' do
             it 'does not use the database' do
               story = Story.create!
@@ -170,8 +216,9 @@ module Cash
 
               describe '#find(1, :conditions => ...)' do
                 it "does not use the database" do
+                  Story.create!
                   story = Story.create!
-                  character = Character.create!(:name => name = 'barbara', :story_id => story)
+                  character = Character.create!(:name => name = 'barbara', :story_id => story.id)
                   mock(Character.connection).execute.never
                   Character.send :with_scope, :find => { :conditions => { :story_id => story.id } } do
                     Character.find(character.id, :conditions => { :name => name }).should == character
@@ -241,6 +288,17 @@ module Cash
                 end
               end
               
+              it "populate cache with compound key" do
+                story = Story.create!
+                harry = story.characters.create! :name => "harry"
+                larry = story.characters.create! :name => "larry"
+                $memcache.flush_all
+
+                Character.find(:all, :conditions => {:story_id => story.id, :name => [larry.name, harry.name]})
+                Character.fetch("name/#{harry.name}/story_id/#{story.id}").should == [harry.id]
+                Character.fetch("name/#{larry.name}/story_id/#{story.id}").should == [larry.id]
+              end
+              
               it "should not create a key over 250 characters with hash for conditions" do
                 150.times do
                   Story.create!
@@ -354,6 +412,11 @@ module Cash
             Story.find(:first, :conditions => { :title => @story.title })
             Story.fetch("title/#{@story.title}").should == [@story.id]
           end
+          
+          it 'populates the cache when database is case insensitive - fails under sqlite (case sensitive)' do
+            Story.find(:first, :conditions => { :title => @story.title.upcase })
+            Story.fetch("title/#{@story.title.upcase}").should == [@story.id]
+          end
         end
 
         describe '#find_by_attr' do
@@ -361,6 +424,11 @@ module Cash
             Story.find_by_title(@story.title)
             Story.fetch("title/#{@story.title}").should == [@story.id]
           end
+          
+          it 'populates the cache with empty array for non-existent value' do
+            Story.find_by_title("blah")
+            Story.fetch("title/blah").should == []
+          end
         end
 
         describe '#find(:all, :conditions => ...)' do
@@ -383,13 +451,124 @@ module Cash
           end
         end
 
+        describe '#find(:conditions => ["... :attr", {:attr => 1}])' do
+          it 'retrieves story from database - no support yet for retrieving from cache' do
+            Story.find(:all, :conditions => ["id = :id", {:id => @story.id}]).should == [@story]
+          end
+        end
+        
         describe '#find(1)' do
           it 'populates the cache' do
             Story.find(@story.id)
-            Story.fetch("id/#{@story.id}").should == [@story]
+            Story.fetch("id/#{@story.id}").should == @story
           end
         end
+        
+        describe '#find(1,2)' do
+          
+          it 'populates the cache' do
+            another_story = Story.create!
+            $memcache.flush_all
+            
+            Story.find(@story.id, another_story.id).should == [@story, another_story]
+            Story.fetch("id/#{@story.id}").should == @story
+            Story.fetch("id/#{another_story.id}").should == another_story
+          end
+          
+          it "populates the cache and retrieves from the cache" do
+            story1 = Story.create!
+            story2 = Story.create!
+            story3 = Story.create!
+            $memcache.flush_all
+
+            Story.find(story1.id, story2.id, story3.id).should == [story1, story2, story3]
+            mock(Story.connection).execute.never
+            Story.find(story1.id, story2.id).should == [story1, story2]
+          end
+          
+          it "uses database for single missing key" do
+            story1 = Story.create!
+            story2 = Story.create!
+            story3 = Story.create!
+            $memcache.flush_all
+
+            Story.find(story1.id, story3.id).should == [story1, story3]
+            Story.fetch("id/#{story2.id}").should be_nil
+
+            quoted_table_name = Story.quoted_table_name
+            quoted_column_name = Story.connection.quote_column_name("id")
+            mock(Story).find_every_without_cache(:limit => nil, 
+                :conditions => "#{quoted_table_name}.#{quoted_column_name} = #{story2.id}") do 
+              story2
+            end
+            Story.find(story1.id, story2.id)
+          end
+          
+          it "uses database for all missing keys" do
+            story1 = Story.create!
+            story2 = Story.create!
+            story3 = Story.create!
+            $memcache.flush_all
+
+            Story.find(story2.id).should == story2
+            Story.fetch("id/#{story1.id}").should be_nil
+            Story.fetch("id/#{story3.id}").should be_nil
+
+            quoted_table_name = Story.quoted_table_name
+            quoted_column_name = Story.connection.quote_column_name("id")
+            mock(Story).find_every_without_cache(:limit => nil, 
+                :conditions => "#{quoted_table_name}.#{quoted_column_name} IN (#{story1.id},#{story3.id})") do 
+              [story1, story3]
+            end
+            Story.find(story1.id, story2.id, story3.id)
+          end
+          
+          it "populates and retrieves from cache when passing in a hash" do
+            story1 = Story.create!
+            story2 = Story.create!
+            $memcache.flush_all
+
+            Story.find(:all, :conditions => {:id => [story1.id, story2.id]})
+            mock(Story.connection).execute.never
+            Story.find(story1.id, story2.id)
+          end
+
+          it "populates and retrieves from cache when passing in a parametrized conditions" do
+            story1 = Story.create!
+            story2 = Story.create!
+            $memcache.flush_all
 
+            Story.find(:all, :conditions => ["id IN (?,?)", story1.id, story2.id])
+            mock(Story.connection).execute.never
+            Story.find(story1.id, story2.id)
+          end
+
+          it "populates and retrieves from cache when passing in a list of non-numeric keys" do
+            pending "need to fix regex to properly parse this"
+            story1 = Story.create! :title => 'one'
+            story2 = Story.create! :title => 'two'
+            $memcache.flush_all
+
+            Story.find(:all, :conditions => ["title IN ('one', 'two')"])
+            # We need to add this extra call as cache money will always go to the database
+            #  one more time when finding by a non-id field first
+            Story.find_all_by_title(['one', 'two'])
+            mock(Story.connection).execute.never
+            Story.find(story1.id, story2.id)
+          end
+          
+          it "should not create a key over 250 characters on a find_all_by_ids" do
+            75.times do
+              Story.create!
+            end
+            ids = Story.find(:all).map(&:id)
+            $memcache.flush_all
+            lambda do 
+              Story.find(:all, :conditions => {:id => ids})
+            end.should_not raise_error(ArgumentError)
+          end
+        end
+        
         describe 'when there is a with_scope' do
           it "uses the database, not the cache" do
             Story.send :with_scope, :find => { :conditions => { :title => @story.title }} do
@@ -397,6 +576,30 @@ module Cash
             end
           end
         end
+        
+        it 'populates the cache correctly when arguments are unordered' do
+          another_story = Story.create!
+          $memcache.flush_all
+          
+          Story.find(another_story.id, @story.id)
+          Story.fetch("id/#{@story.id}").should == @story
+          Story.fetch("id/#{another_story.id}").should == another_story
+        end
+        
+        describe 'ordering' do
+          it 'returns data in correct order' do
+            story1 = Story.create!
+            story2 = Story.create!
+            story3 = Story.create!
+            story4 = Story.create!
+            $memcache.flush_all
+
+            Story.find(story1.id, story3.id)
+            unordered_fairy_tales = [story4.id, story3.id, story2.id, story1.id]
+            ordered_fairy_tales = Story.find(:all, :conditions => ["id IN (?)", unordered_fairy_tales], :order => 'id ASC')     
+            ordered_fairy_tales.should == [story1, story2, story3, story4]
+          end
+        end
       end
     end
   end

data/spec/cash/order_spec.rb

@@ -1,6 +1,7 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 module Cash
+  # for now, all order queries will go to database and bypass cache"
   describe 'Ordering' do
     before :suite do
       FairyTale = Class.new(Story)
@@ -79,6 +80,7 @@ module Cash
         describe "#find(..., :order => 'id ASC')" do
           describe 'when the cache is populated' do
             it 'does not use the database' do
+              pending "for now, all order queries will go to database and bypass cache"
               mock(FairyTale.connection).execute.never
               FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id ASC').should == @fairy_tales
               FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id').should == @fairy_tales
@@ -91,6 +93,7 @@ module Cash
 
           describe 'when the cache is not populated' do
             it 'populates the cache' do
+              pending "for now, all order queries will go to database and bypass cache"              
               $memcache.flush_all
               FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id ASC').should == @fairy_tales
               FairyTale.get("title/#{@title}").should == @fairy_tales.collect(&:id)
@@ -124,6 +127,7 @@ module Cash
         describe "#find(..., :order => 'id DESC')" do
           describe 'when the cache is populated' do
             it 'does not use the database' do
+              pending "for now, all order queries will go to database and bypass cache"
               mock(FairyTale.connection).execute.never
               FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC').should == @fairy_tales.reverse
               FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC').should == @fairy_tales.reverse
@@ -136,6 +140,7 @@ module Cash
 
           describe 'when the cache is not populated' do
             it 'populates the cache' do
+              pending "for now, all order queries will go to database and bypass cache"              
               $memcache.flush_all
               FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC')
               FairyTale.get("title/#{@title}").should == @fairy_tales.collect(&:id).reverse

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: onyx-cache-money
 version: !ruby/object:Gem::Version 
-  version: 0.2.5.8
+  version: 0.2.6
 platform: ruby
 authors: 
 - Nick Kallen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-28 00:00:00 -07:00
+date: 2009-06-18 00:00:00 -07:00
 default_executable: 
 dependencies: []