dynamoid 0.1.2 → 0.2.0

data/lib/dynamoid/indexes/index.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+  module Indexes
+
+    # The class abstracts information about an index
+    class Index
+      attr_accessor :source, :name, :hash_keys, :range_keys
+      alias_method :range_key?, :range_keys
+      
+      def initialize(source, name, options = {})
+        @source = source
+        
+        if options.delete(:range)
+          @range_keys = sort(name)
+        elsif options[:range_key]
+          @range_keys = sort(options[:range_key])
+        end
+        @hash_keys = sort(name)
+        @name = sort([hash_keys, range_keys])
+        
+        raise Dynamoid::Errors::InvalidField, 'A key specified for an index is not a field' unless keys.all?{|n| source.attributes.include?(n)}
+      end
+      
+      def sort(objs)
+        Array(objs).flatten.compact.uniq.collect(&:to_s).sort.collect(&:to_sym)
+      end
+      
+      def keys
+        [Array(hash_keys) + Array(range_keys)].flatten.uniq
+      end
+      
+      def table_name
+        "#{Dynamoid::Config.namespace}_index_#{source.to_s.downcase}_#{name.collect(&:to_s).collect(&:pluralize).join('_and_')}"
+      end
+      
+      def values(attrs)
+        attrs = attrs.send(:attributes) if attrs.respond_to?(:attributes)
+        {}.tap do |hash|
+          hash[:hash_value] = hash_keys.collect{|key| attrs[key]}.join('.')
+          hash[:range_value] = range_keys.inject(0.0) {|sum, key| sum + attrs[key].to_f} if self.range_key?
+        end
+      end
+      
+      def save(obj)
+        values = values(obj)
+        return true if values[:hash_value].blank? || (!values[:range_value].nil? && values[:range_value].blank?)
+        existing = Dynamoid::Adapter.read(self.table_name, values[:hash_value], values[:range_value])
+        ids = ((existing and existing[:ids]) or Set.new)
+        Dynamoid::Adapter.write(self.table_name, {:id => values[:hash_value], :ids => ids.merge([obj.id]), :range => values[:range_value]})
+      end
+      
+      def delete(obj)
+        values = values(obj)
+        return true if values[:hash_value].blank? || (!values[:range_value].nil? && values[:range_value].blank?)
+        existing = Dynamoid::Adapter.read(self.table_name, values[:hash_value], values[:range_value])
+        return true unless existing && existing[:ids] && existing[:ids].include?(obj.id)
+        Dynamoid::Adapter.write(self.table_name, {:id => values[:hash_value], :ids => (existing[:ids] - Set[obj.id]), :range => values[:range_value]})
+      end
+      
+    end
+  end
+end

data/lib/dynamoid/persistence.rb

@@ -15,8 +15,8 @@ module Dynamoid #:nodoc:
         "#{Dynamoid::Config.namespace}_#{self.to_s.downcase.pluralize}"
       end
       
-      def create_table(table_name, id = :id)
-        Dynamoid::Adapter.tables << table_name if Dynamoid::Adapter.create_table(table_name, id.to_sym)
+      def create_table(table_name, id = :id, options = {})
+        Dynamoid::Adapter.tables << table_name if Dynamoid::Adapter.create_table(table_name, id.to_sym, options)
       end
       
       def table_exists?(table_name)
@@ -43,7 +43,11 @@ module Dynamoid #:nodoc:
                 hash[attribute] = Set[value]
               end
             when :datetime
-              hash[attribute] = Time.at(value).to_datetime
+              if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
+                hash[attribute] = value
+              else
+                hash[attribute] = Time.at(value).to_datetime
+              end
             end
           end
         end

data/spec/app/models/user.rb

@@ -4,10 +4,14 @@ class User
   field :name
   field :email
   field :password
+  field :last_logged_in_at, :datetime
   
   index :name
   index :email
   index [:name, :email]
+  index :name, :range_key => :created_at
+  index :name, :range_key => :last_logged_in_at
+  index :created_at, :range => true
   
   has_and_belongs_to_many :subscriptions
 end

data/spec/dynamoid/adapter/aws_sdk_spec.rb

@@ -8,10 +8,10 @@ describe Dynamoid::Adapter::AwsSdk do
     context 'without a preexisting table' do
       # CreateTable and DeleteTable
       it 'performs CreateTable and DeleteTable' do
-        table = Dynamoid::Adapter.create_table('CreateTable', :id)
-
+        table = Dynamoid::Adapter.create_table('CreateTable', :id, :range_key => :created_at)
+    
         Dynamoid::Adapter.connection.tables.collect{|t| t.name}.should include 'CreateTable'
-
+    
         Dynamoid::Adapter.delete_table('CreateTable')
       end
     end
@@ -20,6 +20,7 @@ describe Dynamoid::Adapter::AwsSdk do
       before(:all) do
         Dynamoid::Adapter.create_table('dynamoid_tests_TestTable1', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable1')
         Dynamoid::Adapter.create_table('dynamoid_tests_TestTable2', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable2')
+        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable3', :id, :range_key => :range) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable3')
       end
 
       # GetItem, PutItem and DeleteItem
@@ -37,6 +38,16 @@ describe Dynamoid::Adapter::AwsSdk do
         Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should be_nil
       end
       
+      it 'performs GetItem for an item that does exist with a range key' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 2.0})
+
+        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', 2.0).should == {:name => 'Josh', :id => '1', :range => 2.0}
+
+        Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable3', '1', 2.0)
+        
+        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', 2.0).should be_nil        
+      end
+      
       it 'performs DeleteItem for an item that does not exist' do
         Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable1', '1')
 
@@ -70,6 +81,25 @@ describe Dynamoid::Adapter::AwsSdk do
         results['dynamoid_tests_TestTable1'].should include({:name => 'Justin', :id => '2'})
       end
       
+      it 'performs BatchGetItem with one ranged key' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
+        
+        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0]])
+        results.size.should == 1
+        results['dynamoid_tests_TestTable3'].should include({:name => 'Josh', :id => '1', :range => 1.0})
+      end
+      
+      it 'performs BatchGetItem with multiple ranged keys' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
+        
+        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0],['2', 2.0]])
+        results.size.should == 1
+        results['dynamoid_tests_TestTable3'].should include({:name => 'Josh', :id => '1', :range => 1.0})
+        results['dynamoid_tests_TestTable3'].should include({:name => 'Justin', :id => '2', :range => 2.0})
+      end
+      
       # ListTables
       it 'performs ListTables' do
         Dynamoid::Adapter.list_tables.should include 'dynamoid_tests_TestTable1'
@@ -80,14 +110,41 @@ describe Dynamoid::Adapter::AwsSdk do
       it 'performs query on a table and returns items' do
         Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
 
-        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', '1').should == { :id=> '1', :name=>"Josh" }
+        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
       end
 
       it 'performs query on a table and returns items if there are multiple items' do
         Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
         Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
 
-        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', '1').should == { :id=> '1', :name=>"Josh" }
+        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
+      end
+      
+      context 'range queries' do
+        before do
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :range => 1.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :range => 3.0})
+        end
+
+        it 'performs query on a table with a range and selects items in a range' do      
+          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_value => 0.0..3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+        end
+
+        it 'performs query on a table with a range and selects items greater than' do      
+          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_greater_than => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(3)}]
+        end
+
+        it 'performs query on a table with a range and selects items less than' do      
+          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_less_than => 2.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}]
+        end
+
+        it 'performs query on a table with a range and selects items gte' do      
+          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_gte => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+        end
+
+        it 'performs query on a table with a range and selects items lte' do      
+          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_lte => 3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+        end
       end
 
       # Scan
@@ -116,9 +173,7 @@ describe Dynamoid::Adapter::AwsSdk do
         Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Josh'})
 
         Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', {}).should == [{:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"}] 
-      end
-      
-      
+      end  
     end
     
     # DescribeTable

data/spec/dynamoid/adapter/local_spec.rb

@@ -28,6 +28,28 @@ describe Dynamoid::Adapter::Local do
       results['table1'].should include({:name => 'Josh', :id => '1'})
       results['table1'].should include({:name => 'Justin', :id => '2'})
     end
+    
+    it 'performs BatchGetItem with range keys' do
+      Dynamoid::Adapter.create_table('table1', :id, :range_key => :range)
+      Dynamoid::Adapter.put_item('table1', {:id => '1', :range => 1.0})
+      Dynamoid::Adapter.put_item('table1', {:id => '2', :range => 2.0})
+    
+      results = Dynamoid::Adapter.batch_get_item('table1' => [['1', 1.0], ['2', 2.0]])
+      results.size.should == 1
+      results['table1'].should include({:id => '1', :range => 1.0})
+      results['table1'].should include({:id => '2', :range => 2.0})
+    end
+    
+    it 'performs BatchGetItem with range keys on one primary key' do
+      Dynamoid::Adapter.create_table('table1', :id, :range_key => :range)
+      Dynamoid::Adapter.put_item('table1', {:id => '1', :range => 1.0})
+      Dynamoid::Adapter.put_item('table1', {:id => '1', :range => 2.0})
+    
+      results = Dynamoid::Adapter.batch_get_item('table1' => [['1', 1.0], ['1', 2.0]])
+      results.size.should == 1
+      results['table1'].should include({:id => '1', :range => 1.0})
+      results['table1'].should include({:id => '1', :range => 2.0})
+    end
   
     # CreateTable
     it 'performs CreateTable' do
@@ -78,6 +100,14 @@ describe Dynamoid::Adapter::Local do
     
       Dynamoid::Adapter.get_item('Test Table', '1').should == {:id => '1', :name => 'Josh'}
     end
+    
+    it "performs GetItem for an item with a range key" do
+      Dynamoid::Adapter.create_table('Test Table', :id, :range_key => :range)
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :range => 1.0})
+      
+      Dynamoid::Adapter.get_item('Test Table', '1').should be_nil
+      Dynamoid::Adapter.get_item('Test Table', '1', 1.0).should == {:id => '1', :range => 1.0}
+    end
   
     # ListTables
     it 'performs ListTables' do
@@ -93,15 +123,40 @@ describe Dynamoid::Adapter::Local do
       Dynamoid::Adapter.create_table('Test Table', :id)
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
     
-      Dynamoid::Adapter.data['Test Table'].should == { :id => :id, :data => { '1' => { :id=> '1', :name=>"Josh" }}}
+      Dynamoid::Adapter.data['Test Table'].should == {:hash_key=>:id, :range_key=>nil, :data=>{"1."=>{:id=>"1", :name=>"Josh"}}}
     end
+    
+    it 'puts an item twice and overwrites an existing item' do
+      Dynamoid::Adapter.create_table('Test Table', :id)
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Justin'})
+    
+      Dynamoid::Adapter.data['Test Table'].should == {:hash_key=>:id, :range_key=>nil, :data=>{"1."=>{:id=>"1", :name=>"Justin"}}}      
+    end
+    
+    it 'puts an item twice and does not overwrite an existing item if the range key is not the same' do
+      Dynamoid::Adapter.create_table('Test Table', :id, :range_key => :range)
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Justin', :range => 1.0})
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Justin', :range => 2.0})
+    
+      Dynamoid::Adapter.data['Test Table'].should == {:hash_key=>:id, :range_key=>:range, :data=>{"1.1.0"=>{:id=>"1", :name=>"Justin", :range => 1.0}, "1.2.0" => {:id=>"1", :name=>"Justin", :range => 2.0}}}
+    end
+    
+    it 'puts an item twice and does overwrite an existing item if the range key is the same' do
+      Dynamoid::Adapter.create_table('Test Table', :id, :range_key => :range)
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh', :range => 1.0})
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Justin', :range => 1.0})
+    
+      Dynamoid::Adapter.data['Test Table'].should == {:hash_key=>:id, :range_key=>:range, :data=>{"1.1.0"=>{:id=>"1", :name=>"Justin", :range => 1.0}}}      
+    end
+    
   
     # Query
     it 'performs query on a table and returns items' do
       Dynamoid::Adapter.create_table('Test Table', :id)
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
     
-      Dynamoid::Adapter.query('Test Table', '1').should == { :id=> '1', :name=>"Josh" }
+      Dynamoid::Adapter.query('Test Table', :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
     end
   
     it 'performs query on a table and returns items if there are multiple items' do
@@ -109,9 +164,38 @@ describe Dynamoid::Adapter::Local do
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
       Dynamoid::Adapter.put_item('Test Table', {:id => '2', :name => 'Justin'})
     
-      Dynamoid::Adapter.query('Test Table', '1').should == { :id=> '1', :name=>"Josh" }
-    end
-  
+      Dynamoid::Adapter.query('Test Table', :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
+    end
+    
+    context 'range queries' do
+      before do
+        Dynamoid::Adapter.create_table('Test Table', :id, :range_key => :range)
+        Dynamoid::Adapter.put_item('Test Table', {:id => '1', :range => 1.0})
+        Dynamoid::Adapter.put_item('Test Table', {:id => '1', :range => 2.0})        
+      end
+      
+      it 'performs query on a table with a range and selects items in a range' do      
+        Dynamoid::Adapter.query('Test Table', :hash_value => '1', :range_value => 0.0..3.0).should =~ [{:id => '1', :range => 1.0}, {:id => '1', :range => 2.0}]
+      end
+      
+      it 'performs query on a table with a range and selects items greater than' do      
+        Dynamoid::Adapter.query('Test Table', :hash_value => '1', :range_greater_than => 1.0).should =~ [{:id => '1', :range => 2.0}]
+      end
+      
+      it 'performs query on a table with a range and selects items less than' do      
+        Dynamoid::Adapter.query('Test Table', :hash_value => '1', :range_less_than => 2.0).should =~ [{:id => '1', :range => 1.0}]
+      end
+      
+      it 'performs query on a table with a range and selects items gte' do      
+        Dynamoid::Adapter.query('Test Table', :hash_value => '1', :range_gte => 1.0).should =~ [{:id => '1', :range => 1.0}, {:id => '1', :range => 2.0}]
+      end
+      
+      it 'performs query on a table with a range and selects items lte' do      
+        Dynamoid::Adapter.query('Test Table', :hash_value => '1', :range_lte => 2.0).should =~ [{:id => '1', :range => 1.0}, {:id => '1', :range => 2.0}]
+      end
+      
+    end
+      
     # Scan
     it 'performs scan on a table and returns items' do
       Dynamoid::Adapter.create_table('Test Table', :id)

data/spec/dynamoid/adapter_spec.rb

@@ -31,7 +31,7 @@ describe "Dynamoid::Adapter" do
     end
 
     it 'reads through the adapter for one ID' do
-      Dynamoid::Adapter.expects(:get_item).with('dynamoid_tests_TestTable', '123').returns(true)
+      Dynamoid::Adapter.expects(:get_item).with('dynamoid_tests_TestTable', '123', nil).returns(true)
 
       Dynamoid::Adapter.read('dynamoid_tests_TestTable', '123')
     end
@@ -41,6 +41,18 @@ describe "Dynamoid::Adapter" do
 
       Dynamoid::Adapter.read('dynamoid_tests_TestTable', ['1', '2'])
     end
+    
+    it 'reads through the adapter for one ID and a range key' do
+      Dynamoid::Adapter.expects(:get_item).with('dynamoid_tests_TestTable', '123', 2.0).returns(true)
+
+      Dynamoid::Adapter.read('dynamoid_tests_TestTable', '123', 2.0)      
+    end
+    
+    it 'reads through the adapter for many IDs and a range key' do
+      Dynamoid::Adapter.expects(:batch_get_item).with({'dynamoid_tests_TestTable' => [['1', 2.0], ['2', 2.0]]}).returns(true)
+
+      Dynamoid::Adapter.read('dynamoid_tests_TestTable', ['1', '2'], 2.0)
+    end
   end
   
   context 'with partitioning' do
@@ -72,10 +84,26 @@ describe "Dynamoid::Adapter" do
     
       Dynamoid::Adapter.read('dynamoid_tests_TestTable', ['1', '2'])
     end
+    
+    it 'reads through the adapter for one ID and a range key' do
+      Dynamoid::Adapter.expects(:batch_get_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| ["123.#{n}", 2.0]}).returns({})
+    
+      Dynamoid::Adapter.read('dynamoid_tests_TestTable', '123', 2.0)
+    end
+  
+    it 'reads through the adapter for many IDs and a range key' do
+      Dynamoid::Adapter.expects(:batch_get_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| ["1.#{n}", 2.0]} + (0...Dynamoid::Config.partition_size).collect{|n| ["2.#{n}", 2.0]}).returns({})
+    
+      Dynamoid::Adapter.read('dynamoid_tests_TestTable', ['1', '2'], 2.0)
+    end
   
     it 'returns an ID with all partitions' do
       Dynamoid::Adapter.id_with_partitions('1').should =~ (0...Dynamoid::Config.partition_size).collect{|n| "1.#{n}"}
     end
+    
+    it 'returns an ID and range key with all partitions' do
+      Dynamoid::Adapter.id_with_partitions([['1', 1.0]]).should =~ (0...Dynamoid::Config.partition_size).collect{|n| ["1.#{n}", 1.0]}
+    end
   
     it 'returns a result for one partitioned element' do
       @time = DateTime.now

data/spec/dynamoid/criteria/chain_spec.rb

@@ -3,37 +3,52 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe "Dynamoid::Associations::Chain" do
 
   before(:each) do
+    @time = DateTime.now
     @user = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com', :password => 'Test123')
     @chain = Dynamoid::Criteria::Chain.new(User)
   end
   
   it 'finds matching index for a query' do
     @chain.query = {:name => 'Josh'}
-    @chain.send(:index).should == [:name]
+    @chain.send(:index).should == User.indexes[[:name]]
     
     @chain.query = {:email => 'josh@joshsymonds.com'}
-    @chain.send(:index).should == [:email]
+    @chain.send(:index).should == User.indexes[[:email]]
     
     @chain.query = {:name => 'Josh', :email => 'josh@joshsymonds.com'}
-    @chain.send(:index).should == [:email, :name]
+    @chain.send(:index).should == User.indexes[[:email, :name]]
+  end
+  
+  it 'finds matching index for a range query' do
+    @chain.query = {"created_at.gt" => @time - 1.day}
+    @chain.send(:index).should == User.indexes[[:created_at]]
+    
+    @chain.query = {:name => 'Josh', "created_at.lt" => @time - 1.day}
+    @chain.send(:index).should == User.indexes[[:created_at, :name]]
   end
   
   it 'does not find an index if there is not an appropriate one' do
     @chain.query = {:password => 'Test123'}
-    @chain.send(:index).should == []
+    @chain.send(:index).should be_nil
+    
+    @chain.query = {:password => 'Test123', :created_at => @time}
+    @chain.send(:index).should be_nil
   end
   
   it 'returns values for index for a query' do
     @chain.query = {:name => 'Josh'}
-    @chain.send(:values_for_index).should == ['Josh']
+    @chain.send(:index_query).should == {:hash_value => 'Josh'}
     
     @chain.query = {:email => 'josh@joshsymonds.com'}
-    @chain.send(:values_for_index).should == ['josh@joshsymonds.com']
+    @chain.send(:index_query).should == {:hash_value => 'josh@joshsymonds.com'}
     
     @chain.query = {:name => 'Josh', :email => 'josh@joshsymonds.com'}
-    @chain.send(:values_for_index).should == ['josh@joshsymonds.com', 'Josh']
+    @chain.send(:index_query).should == {:hash_value => 'josh@joshsymonds.com.Josh'}
+    
+    @chain.query = {:name => 'Josh', 'created_at.gt' => @time}
+    @chain.send(:index_query).should == {:hash_value => 'Josh', :range_greater_than => @time.to_f}
   end
-  
+    
   it 'finds records with an index' do
     @chain.query = {:name => 'Josh'}
     @chain.send(:records_with_index).should == [@user]
@@ -45,6 +60,14 @@ describe "Dynamoid::Associations::Chain" do
     @chain.send(:records_with_index).should == [@user]
   end
   
+  it 'returns records with an index for a ranged query' do
+    @chain.query = {:name => 'Josh', "created_at.gt" => @time - 1.day}
+    @chain.send(:records_with_index).should == [@user]
+    
+    @chain.query = {:name => 'Josh', "created_at.lt" => @time + 1.day}
+    @chain.send(:records_with_index).should == [@user]
+  end
+  
   it 'finds records without an index' do
     @chain.query = {:password => 'Test123'}
     @chain.send(:records_without_index).should == [@user]