dynamoid 0.6.1 → 0.7.0

data/spec/dynamoid/adapter_spec.rb

@@ -1,17 +1,21 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "Dynamoid::Adapter" do
+describe Dynamoid::Adapter do
   
+  def test_table; 'dynamoid_tests_TestTable'; end
+  let(:single_id){'123'}
+  let(:many_ids){%w(1 2)}
+
   before(:all) do
-    Dynamoid::Adapter.create_table('dynamoid_tests_TestTable', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable')
+    described_class.create_table(test_table, :id) unless described_class.list_tables.include?(test_table)
   end
   
   it 'extends itself automatically' do
-    lambda {Dynamoid::Adapter.list_tables}.should_not raise_error
+    lambda {described_class.list_tables}.should_not raise_error
   end
-  
-  it 'raises nomethod if we try a method that is not on the child' do
-    lambda {Dynamoid::Adapter.foobar}.should raise_error
+
+  it 'raises NoMethodError if we try a method that is not on the child' do
+    lambda {described_class.foobar}.should raise_error(NoMethodError)
   end
   
   context 'without partioning' do
@@ -25,145 +29,126 @@ describe "Dynamoid::Adapter" do
     end
     
     it 'writes through the adapter' do
-      Dynamoid::Adapter.expects(:put_item).with('dynamoid_tests_TestTable', {:id => '123'}, nil).returns(true)
-
-      Dynamoid::Adapter.write('dynamoid_tests_TestTable', {:id => '123'})
+      described_class.expects(:put_item).with(test_table, {:id => single_id}, nil).returns(true)
+      described_class.write(test_table, {:id => single_id})
     end
 
     it 'reads through the adapter for one ID' do
-      Dynamoid::Adapter.expects(:get_item).with('dynamoid_tests_TestTable', '123', {}).returns(true)
-
-      Dynamoid::Adapter.read('dynamoid_tests_TestTable', '123')
+      described_class.expects(:get_item).with(test_table, single_id, {}).returns(true)
+      described_class.read(test_table, single_id)
     end
 
     it 'reads through the adapter for many IDs' do
-      Dynamoid::Adapter.expects(:batch_get_item).with({'dynamoid_tests_TestTable' => ['1', '2']}).returns(true)
-
-      Dynamoid::Adapter.read('dynamoid_tests_TestTable', ['1', '2'])
+      described_class.expects(:batch_get_item).with({test_table => many_ids}, {}).returns(true)
+      described_class.read(test_table, many_ids)
     end
-    
-    it 'delete through the adapter for one ID' do
-      Dynamoid::Adapter.expects(:delete_item).with('dynamoid_tests_TestTable', '123', {}).returns(nil)
 
-      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', '123')
+    it 'delete through the adapter for one ID' do
+      described_class.expects(:delete_item).with(test_table, single_id, {}).returns(nil)
+      described_class.delete(test_table, single_id)
     end
-    
-    it 'deletes through the adapter for many IDs' do
-      Dynamoid::Adapter.expects(:batch_delete_item).with({'dynamoid_tests_TestTable' => ['1', '2']}).returns(nil)
 
-      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', ['1', '2'])
+    it 'deletes through the adapter for many IDs' do
+      described_class.expects(:batch_delete_item).with({test_table => many_ids}).returns(nil)
+      described_class.delete(test_table, many_ids)
     end
-    
-    it 'reads through the adapter for one ID and a range key' do
-      Dynamoid::Adapter.expects(:get_item).with('dynamoid_tests_TestTable', '123', :range_key => 2.0).returns(true)
 
-      Dynamoid::Adapter.read('dynamoid_tests_TestTable', '123', :range_key => 2.0)      
+    it 'reads through the adapter for one ID and a range key' do
+      described_class.expects(:get_item).with(test_table, single_id, :range_key => 2.0).returns(true)
+      described_class.read(test_table, single_id, :range_key => 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'], :range_key => 2.0)
+    it 'reads through the adapter for many IDs and a range key' do
+      described_class.expects(:batch_get_item).with({test_table => [['1', 2.0], ['2', 2.0]]}, {}).returns(true)
+      described_class.read(test_table, many_ids, :range_key => 2.0)
     end
-    
-    it 'deletes through the adapter for one ID and a range key' do
-      Dynamoid::Adapter.expects(:delete_item).with('dynamoid_tests_TestTable', '123', :range_key => 2.0).returns(nil)
 
-      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', '123', :range_key => 2.0)      
+    it 'deletes through the adapter for one ID and a range key' do
+      described_class.expects(:delete_item).with(test_table, single_id, :range_key => 2.0).returns(nil)
+      described_class.delete(test_table, single_id, :range_key => 2.0)
     end
-    
-    it 'deletes through the adapter for many IDs and a range key' do
-      Dynamoid::Adapter.expects(:batch_delete_item).with({'dynamoid_tests_TestTable' => [['1', 2.0], ['2', 2.0]]}).returns(nil)
 
-      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', ['1', '2'], :range_key => [2.0,2.0])
+    it 'deletes through the adapter for many IDs and a range key' do
+      described_class.expects(:batch_delete_item).with({test_table => [['1', 2.0], ['2', 2.0]]}).returns(nil)
+      described_class.delete(test_table, many_ids, :range_key => [2.0,2.0])
     end
   end
   
-  context 'with partitioning' do
-    before(:all) do
-      @previous_value = Dynamoid::Config.partitioning
-      Dynamoid::Config.partitioning = true
-    end
-    
-    after(:all) do
-      Dynamoid::Config.partitioning = @previous_value
-    end
-    
+  configured_with 'partitioning' do
+    let(:partition_range){0...Dynamoid::Config.partition_size}
+
     it 'writes through the adapter' do
       Random.expects(:rand).with(Dynamoid::Config.partition_size).once.returns(0)
-      Dynamoid::Adapter.write('dynamoid_tests_TestTable', {:id => 'testid'})
-    
-      Dynamoid::Adapter.get_item('dynamoid_tests_TestTable', 'testid.0')[:id].should == 'testid.0'
-      Dynamoid::Adapter.get_item('dynamoid_tests_TestTable', 'testid.0')[:updated_at].should_not be_nil
+      described_class.write(test_table, {:id => 'testid'})
+
+      described_class.get_item(test_table, 'testid.0')[:id].should == 'testid.0'
+      described_class.get_item(test_table, 'testid.0')[:updated_at].should_not be_nil
     end
   
     it 'reads through the adapter for one ID' do
-      Dynamoid::Adapter.expects(:batch_get_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| "123.#{n}"}).returns({})
-    
-      Dynamoid::Adapter.read('dynamoid_tests_TestTable', '123')
+      described_class.expects(:batch_get_item).with({test_table => partition_range.map{|n| "123.#{n}"}}, {}).returns({})
+      described_class.read(test_table, single_id)
     end
   
     it 'reads through the adapter for many IDs' do
-      Dynamoid::Adapter.expects(:batch_get_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| "1.#{n}"} + (0...Dynamoid::Config.partition_size).collect{|n| "2.#{n}"}).returns({})
-    
-      Dynamoid::Adapter.read('dynamoid_tests_TestTable', ['1', '2'])
+      described_class.expects(:batch_get_item).with({test_table => partition_range.map{|n| "1.#{n}"} + partition_range.map{|n| "2.#{n}"}}, {}).returns({})
+      described_class.read(test_table, many_ids)
     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', :range_key => 2.0)
+      described_class.expects(:batch_get_item).with({test_table => partition_range.map{|n| ["123.#{n}", 2.0]}}, {}).returns({})
+      described_class.read(test_table, single_id, :range_key => 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'], :range_key => 2.0)
+      described_class.expects(:batch_get_item).with({test_table => partition_range.map{|n| ["1.#{n}", 2.0]} + partition_range.map{|n| ["2.#{n}", 2.0]}}, {}).returns({})
+      described_class.read(test_table, many_ids, :range_key => 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}"}
+      described_class.id_with_partitions('1').should =~ partition_range.map{|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]}
+      described_class.id_with_partitions([['1', 1.0]]).should =~ partition_range.map{|n| ["1.#{n}", 1.0]}
     end
   
     it 'returns a result for one partitioned element' do
       @time = DateTime.now
-      @array =[{:id => '1.0', :updated_at => @time - 6.hours}, {:id => '1.1', :updated_at => @time - 3.hours}, {:id => '1.2', :updated_at => @time - 1.hour}, {:id => '1.3', :updated_at => @time - 6.hours}, {:id => '2.0', :updated_at => @time}]
+      @array =[{:id => '1.0', :updated_at => @time - 6.hours},
+               {:id => '1.1', :updated_at => @time - 3.hours},
+               {:id => '1.2', :updated_at => @time - 1.hour},
+               {:id => '1.3', :updated_at => @time - 6.hours},
+               {:id => '2.0', :updated_at => @time}]
     
-      Dynamoid::Adapter.result_for_partition(@array,"dynamoid_tests_TestTable").should =~ [{:id => '1', :updated_at => @time - 1.hour}, {:id => '2', :updated_at => @time}]
+      described_class.result_for_partition(@array,test_table).should =~ [{:id => '1', :updated_at => @time - 1.hour},
+                                                                           {:id => '2', :updated_at => @time}]
     end
     
     it 'returns a valid original id and partition number' do
       @id = "12345.387327.-sdf3"
       @partition_number = "4"
-      Dynamoid::Adapter.get_original_id_and_partition("#{@id}.#{@partition_number}").should == [@id, @partition_number]
+      described_class.get_original_id_and_partition("#{@id}.#{@partition_number}").should == [@id, @partition_number]
     end
     
     it 'delete through the adapter for one ID' do
-      Dynamoid::Adapter.expects(:batch_delete_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| "123.#{n}"}).returns(nil)
-
-      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', '123')
+      described_class.expects(:batch_delete_item).with(test_table => partition_range.map{|n| "123.#{n}"}).returns(nil)
+      described_class.delete(test_table, single_id)
     end
     
     it 'deletes through the adapter for many IDs' do
-      Dynamoid::Adapter.expects(:batch_delete_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| "1.#{n}"} + (0...Dynamoid::Config.partition_size).collect{|n| "2.#{n}"}).returns(nil)
-
-      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', ['1', '2'])
+      described_class.expects(:batch_delete_item).with(test_table => partition_range.map{|n| "1.#{n}"} + partition_range.map{|n| "2.#{n}"}).returns(nil)
+      described_class.delete(test_table, many_ids)
     end
     
     it 'deletes through the adapter for one ID and a range key' do
-      Dynamoid::Adapter.expects(:batch_delete_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| ["123.#{n}", 2.0]}).returns(nil)
-
-      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', '123', :range_key => 2.0)      
+      described_class.expects(:batch_delete_item).with(test_table => partition_range.map{|n| ["123.#{n}", 2.0]}).returns(nil)
+      described_class.delete(test_table, single_id, :range_key => 2.0)      
     end
     
     it 'deletes through the adapter for many IDs and a range key' do
-      Dynamoid::Adapter.expects(:batch_delete_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(nil)
-
-      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', ['1', '2'], :range_key => [2.0,2.0])
+      described_class.expects(:batch_delete_item).with(test_table => partition_range.map{|n| ["1.#{n}", 2.0]} + partition_range.map{|n| ["2.#{n}", 2.0]}).returns(nil)
+      described_class.delete(test_table, many_ids, :range_key => [2.0,2.0])
     end
   end
 

data/spec/dynamoid/associations/association_spec.rb

@@ -6,30 +6,30 @@ describe "Dynamoid::Associations::Association" do
     Subscription.create_table
     @magazine = Magazine.create
   end
-  
+
   it 'returns an empty array if there are no associations' do
     @magazine.subscriptions.should be_empty
   end
-  
+
   it 'adds an item to an association' do
     @subscription = Subscription.create
-    
+
     @magazine.subscriptions << @subscription
     @magazine.subscriptions.size.should == 1
     @magazine.subscriptions.should include @subscription
   end
-  
+
   it 'deletes an item from an association' do
     @subscription = Subscription.create
     @magazine.subscriptions << @subscription
-    
+
     @magazine.subscriptions.delete(@subscription)
     @magazine.subscriptions.size.should == 0
   end
-  
+
   it 'creates an item from an association' do
     @subscription = @magazine.subscriptions.create
-    
+
     @subscription.class.should == Subscription
     @magazine.subscriptions.size.should == 1
     @magazine.subscriptions.should include @subscription
@@ -38,7 +38,7 @@ describe "Dynamoid::Associations::Association" do
   it 'returns the number of items in the association' do
     @magazine.subscriptions.create
     @magazine.subscriptions.size.should == 1
-    
+
     @second = @magazine.subscriptions.create
     @magazine.subscriptions.size.should == 2
 
@@ -48,61 +48,61 @@ describe "Dynamoid::Associations::Association" do
     @magazine.subscriptions = []
     @magazine.subscriptions.size.should == 0
   end
-  
+
   it 'assigns directly via the equals operator' do
     @subscription = Subscription.create
     @magazine.subscriptions = [@subscription]
-    
+
     @magazine.subscriptions.should == [@subscription]
   end
-  
+
   it 'assigns directly via the equals operator and reflects to the target association' do
     @subscription = Subscription.create
     @magazine.subscriptions = [@subscription]
-    
+
     @subscription.magazine.should == @magazine
   end
-  
+
   it 'does not assign reflection association if the reflection association does not exist' do
     @sponsor = Sponsor.create
-    
+
     @subscription = @sponsor.subscriptions.create
     @subscription.should_not respond_to :sponsor
     @subscription.should_not respond_to :sponsors
     @subscription.should_not respond_to :sponsors_ids
     @subscription.should_not respond_to :sponsor_ids
   end
-  
+
   it 'deletes all items from the association' do
     @magazine.subscriptions << Subscription.create
     @magazine.subscriptions << Subscription.create
     @magazine.subscriptions << Subscription.create
-    
+
     @magazine.subscriptions.size.should == 3
-    
+
     @magazine.subscriptions = nil
     @magazine.subscriptions.size.should == 0
   end
-  
+
   it 'uses where inside an association and returns a result' do
     @included_subscription = @magazine.subscriptions.create(:length => 10)
     @unincldued_subscription = @magazine.subscriptions.create(:length => 8)
-    
+
     @magazine.subscriptions.where(:length => 10).all.should == [@included_subscription]
   end
-  
+
   it 'uses where inside an association and returns an empty set' do
     @included_subscription = @magazine.subscriptions.create(:length => 10)
     @unincldued_subscription = @magazine.subscriptions.create(:length => 8)
-    
+
     @magazine.subscriptions.where(:length => 6).all.should be_empty
   end
-  
+
   it 'includes enumerable' do
     @subscription1 = @magazine.subscriptions.create
     @subscription2 = @magazine.subscriptions.create
     @subscription3 = @magazine.subscriptions.create
-    
+
     @magazine.subscriptions.collect(&:id).should =~ [@subscription1.id, @subscription2.id, @subscription3.id]
   end
 
@@ -134,41 +134,41 @@ describe "Dynamoid::Associations::Association" do
   #
   #  @magazine.subscriptions.instance_eval { [first, last] }.should == [@subscription1, @subscription3]
   #end
-  
+
   it 'replaces existing associations when using the setter' do
     @subscription1 = @magazine.subscriptions.create
     @subscription2 = @magazine.subscriptions.create
     @subscription3 = Subscription.create
-    
+
     @subscription1.reload.magazine_ids.should_not be_nil
     @subscription2.reload.magazine_ids.should_not be_nil
 
     @magazine.subscriptions = @subscription3
     @magazine.subscriptions_ids.should == Set[@subscription3.id]
-    
+
     @subscription1.reload.magazine_ids.should be_nil
     @subscription2.reload.magazine_ids.should be_nil
     @subscription3.reload.magazine_ids.should == Set[@magazine.id]
   end
-  
+
   it 'destroys all objects and removes them from the association' do
     @subscription1 = @magazine.subscriptions.create
     @subscription2 = @magazine.subscriptions.create
     @subscription3 = @magazine.subscriptions.create
 
     @magazine.subscriptions.destroy_all
-    
+
     @magazine.subscriptions.should be_empty
     Subscription.all.should be_empty
   end
-  
+
   it 'deletes all objects and removes them from the association' do
     @subscription1 = @magazine.subscriptions.create
     @subscription2 = @magazine.subscriptions.create
     @subscription3 = @magazine.subscriptions.create
 
     @magazine.subscriptions.delete_all
-    
+
     @magazine.subscriptions.should be_empty
     Subscription.all.should be_empty
   end

data/spec/dynamoid/criteria/chain_spec.rb

@@ -19,6 +19,11 @@ describe "Dynamoid::Associations::Chain" do
     @chain.send(:index).should == User.indexes[[:email, :name]]
   end
 
+  it 'makes string symbol for query keys' do
+    @chain.query = {'name' => 'Josh'}
+    @chain.send(:index).should == User.indexes[[: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]]
@@ -51,26 +56,26 @@ describe "Dynamoid::Associations::Chain" do
 
   it 'finds records with an index' do
     @chain.query = {:name => 'Josh'}
-    @chain.send(:records_with_index).should == [@user]
+    @chain.send(:records_with_index).should == @user
 
     @chain.query = {:email => 'josh@joshsymonds.com'}
-    @chain.send(:records_with_index).should == [@user]
+    @chain.send(:records_with_index).should == @user
 
     @chain.query = {:name => 'Josh', :email => 'josh@joshsymonds.com'}
-    @chain.send(:records_with_index).should == [@user]
+    @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.send(:records_with_index).should == @user
 
     @chain.query = {:name => 'Josh', "created_at.lt" => @time + 1.day}
-    @chain.send(:records_with_index).should == [@user]
+    @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]
+    @chain.send(:records_without_index).to_a.should == [@user]
   end
 
   it "doesn't crash if it finds a nil id in the index" do
@@ -94,14 +99,38 @@ describe "Dynamoid::Associations::Chain" do
     @chain.collect {|u| u.name}.should == ['Josh']
   end
 
-  it 'finds range querys' do
+  it 'uses a range query when only a hash key or range key is specified in query' do
+    # Primary key is [hash_key].
+    @chain = Dynamoid::Criteria::Chain.new(Address)
+    @chain.query = {}
+    @chain.send(:range?).should be_false
+
+    @chain = Dynamoid::Criteria::Chain.new(Address)
+    @chain.query = { :id => 'test' }
+    @chain.send(:range?).should be_true
+
+    @chain = Dynamoid::Criteria::Chain.new(Address)
+    @chain.query = { :id => 'test', :city => 'Bucharest' }
+    @chain.send(:range?).should be_false
+
+    # Primary key is [hash_key, range_key].
+    @chain = Dynamoid::Criteria::Chain.new(Tweet)
+    @chain.query = { }
+    @chain.send(:range?).should be_false
+
     @chain = Dynamoid::Criteria::Chain.new(Tweet)
     @chain.query = { :tweet_id => 'test' }
     @chain.send(:range?).should be_true
 
+    @chain.query = {:tweet_id => 'test', :msg => 'hai'}
+    @chain.send(:range?).should be_false
+
     @chain.query = {:tweet_id => 'test', :group => 'xx'}
     @chain.send(:range?).should be_true
 
+    @chain.query = {:tweet_id => 'test', :group => 'xx', :msg => 'hai'}
+    @chain.send(:range?).should be_false
+
     @chain.query = { :group => 'xx' }
     @chain.send(:range?).should be_false
 
@@ -119,7 +148,7 @@ describe "Dynamoid::Associations::Chain" do
 
     it 'finds tweets with a simple range query' do
       @chain.query = { :tweet_id => "x" }
-      @chain.send(:records_with_range).size.should == 2
+      @chain.send(:records_with_range).to_a.size.should == 2
       @chain.all.size.should == 2
       @chain.limit(1).size.should == 1
     end
@@ -133,7 +162,7 @@ describe "Dynamoid::Associations::Chain" do
     it 'finds one specific tweet' do
       @chain = Dynamoid::Criteria::Chain.new(Tweet)
       @chain.query = { :tweet_id => "xx", :group => "two" }
-      @chain.send(:records_with_range).should == [@tweet3]
+      @chain.send(:records_with_range).to_a.should == [@tweet3]
     end
   end
   
@@ -160,4 +189,22 @@ describe "Dynamoid::Associations::Chain" do
       @chain.consistent.all.size.should == 0
     end
   end
+
+  context 'batch queries' do
+    before do
+      @tweets = (1..4).map{|count| Tweet.create(:tweet_id => count.to_s, :group => (count % 2).to_s)}
+      @chain = Dynamoid::Criteria::Chain.new(Tweet)
+    end
+
+    it 'returns all results' do
+      @chain.batch(2).all.to_a.size.should == @tweets.size
+    end
+
+    it 'throws exception if partitioning is used with batching' do
+      previous_value = Dynamoid::Config.partitioning
+      Dynamoid::Config.partitioning = true
+      expect { @chain.batch(2) }.to raise_error
+      Dynamoid::Config.partitioning = previous_value
+    end
+  end
 end