dynamoid 0.6.1 → 0.7.0

data/spec/dynamoid/criteria_spec.rb

@@ -1,6 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe "Dynamoid::Criteria" do
+  before(:all) do
+    Magazine.create_table
+  end
   
   before do
     @user1 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')

data/spec/dynamoid/dirty_spec.rb

@@ -22,6 +22,14 @@ describe 'Dynamoid::Dirty' do
       tweet.reload
       tweet.changed?.should be_false
     end
+    
+    it 'should be empty after an update' do
+      tweet = Tweet.create!(:tweet_id => "1", :group => 'abc')
+      tweet.update! do |t|
+        t.set(msg: "foo")
+      end
+      tweet.changed?.should be_false
+    end
 
     it 'track changes after saves' do
       tweet = Tweet.new(:tweet_id => "1", :group => 'abc')

data/spec/dynamoid/document_spec.rb

@@ -4,9 +4,9 @@ describe "Dynamoid::Document" do
 
   it 'initializes a new document' do
     @address = Address.new
-    
+
     @address.new_record.should be_true
-    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>nil, :options=>nil, :deliverable => nil}
+    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>nil, :options=>nil, :deliverable => nil, :lock_version => nil}
   end
 
   it 'responds to will_change! methods for all fields' do
@@ -16,21 +16,21 @@ describe "Dynamoid::Document" do
     @address.should respond_to(:created_at_will_change!)
     @address.should respond_to(:updated_at_will_change!)
   end
-  
+
   it 'initializes a new document with attributes' do
     @address = Address.new(:city => 'Chicago')
-    
+
     @address.new_record.should be_true
-    
-    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>"Chicago", :options=>nil, :deliverable => nil}
+
+    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>"Chicago", :options=>nil, :deliverable => nil, :lock_version => nil}
   end
 
   it 'initializes a new document with a virtual attribute' do
     @address = Address.new(:zip_code => '12345')
-    
+
     @address.new_record.should be_true
-    
-    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>"Chicago", :options=>nil, :deliverable => nil}
+
+    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>"Chicago", :options=>nil, :deliverable => nil, :lock_version => nil}
   end
 
   it 'allows interception of write_attribute on load' do
@@ -41,10 +41,10 @@ describe "Dynamoid::Document" do
     end
     Model.new(:city => "Chicago").city.should == "chicago"
   end
-  
+
   it 'creates a new document' do
     @address = Address.create(:city => 'Chicago')
-    
+
     @address.new_record.should be_false
     @address.id.should_not be_nil
   end
@@ -53,61 +53,54 @@ describe "Dynamoid::Document" do
     @address = Address.create(:city => 'Chicago')
     Address.exists?(@address.id).should be_true
     Address.exists?("does-not-exist").should be_false
-  end
-  
-  it 'tests equivalency with itself' do
-    @address = Address.create(:city => 'Chicago')
-    
-    @address.should == @address
+    Address.exists?(:city => @address.city).should be_true
+    Address.exists?(:city => "does-not-exist").should be_false
   end
 
-  it 'is not equivalent to another document' do
-    @address.should_not == Address.create
-  end
-  
-  it 'is not equivalent to another object' do
-    @address = Address.create(:city => 'Chicago')
-    @address.should_not == "test"
-  end
-  
-  it "isn't equal to nil" do
-    @address = Address.create(:city => 'Chicago')
-    @address.should_not == nil
-  end
-  
   it 'gets errors courtesy of ActiveModel' do
     @address = Address.create(:city => 'Chicago')
-    
+
     @address.errors.should be_empty
     @address.errors.full_messages.should be_empty
   end
-  
-  it 'reloads itself and sees persisted changes' do
-    @address = Address.create
-    
-    Address.first.update_attributes(:city => 'Chicago')
-    
-    @address.reload.city.should == 'Chicago'
-  end
 
-  it 'reloads document with range key' do
-    tweet = Tweet.create(:tweet_id => 'x', :group => 'abc')
-    tweet.reload.group.should == 'abc'
+  context '.reload' do
+    let(:address){ Address.create }
+    let(:message){ Message.create({:text => 'Nice, supporting datetime range!', :time => Time.now.to_datetime}) }
+    let(:tweet){ tweet = Tweet.create(:tweet_id => 'x', :group => 'abc') }
+
+    it 'reflects persisted changes' do
+      address.update_attributes(:city => 'Chicago')
+      address.reload.city.should == 'Chicago'
+    end
+
+    it 'uses a :consistent_read' do
+      Tweet.expects(:find).with(tweet.hash_key, {:range_key => tweet.range_value, :consistent_read => true}).returns(tweet)
+      tweet.reload
+    end
+
+    it 'works with range key' do
+      tweet.reload.group.should == 'abc'
+    end
+
+    it 'works with a :datetime range key' do
+      expect { message.reload }.to_not raise_error(ArgumentError)
+    end
   end
-  
+
   it 'has default table options' do
     @address = Address.create
-    
+
     @address.id.should_not be_nil
     Address.table_name.should == 'dynamoid_tests_addresses'
     Address.hash_key.should == :id
     Address.read_capacity.should == 100
     Address.write_capacity.should == 20
   end
-  
+
   it 'follows any table options provided to it' do
     @tweet = Tweet.create(:group => 12345)
-    
+
     lambda {@tweet.id}.should raise_error(NoMethodError)
     @tweet.tweet_id.should_not be_nil
     Tweet.table_name.should == 'dynamoid_tests_twitters'
@@ -115,4 +108,73 @@ describe "Dynamoid::Document" do
     Tweet.read_capacity.should == 200
     Tweet.write_capacity.should == 200
   end
+
+  shared_examples 'it has equality testing and hashing' do
+    it 'is equal to itself' do
+      document.should == document
+    end
+
+    it 'is equal to another document with the same key(s)' do
+      document.should == same
+    end
+
+    it 'is not equal to another document with different key(s)' do
+      document.should_not == different
+    end
+
+    it 'is not equal to an object that is not a document' do
+      document.should_not == 'test'
+    end
+
+    it 'is not equal to nil' do
+      document.should_not == nil
+    end
+
+    it 'hashes documents with the keys to the same value' do
+      {document => 1}.should have_key(same)
+    end
+  end
+
+  context 'without a range key' do
+    it_behaves_like 'it has equality testing and hashing' do
+      let(:document) { Address.create(id: 123, city: 'Seattle') }
+      let(:different) { Address.create(id: 456, city: 'Seattle') }
+      let(:same) { Address.new(id: 123, city: 'Boston') }
+    end
+  end
+
+  context 'with a range key' do
+    it_behaves_like 'it has equality testing and hashing' do
+      let(:document){ Tweet.create(:tweet_id => 'x', :group => 'abc', :msg => 'foo') }
+      let(:different) { Tweet.create(:tweet_id => 'y', :group => 'abc', :msg => 'foo') }
+      let(:same) { Tweet.new(:tweet_id => 'x', :group => 'abc', :msg => 'bar') }
+    end
+
+    it 'is not equal to another document with the same hash key but a different range value' do
+      document = Tweet.create(:tweet_id => 'x', :group => 'abc')
+      different = Tweet.create(:tweet_id => 'x', :group => 'xyz')
+
+      document.should_not == different
+    end
+  end
+
+  context 'single table inheritance' do
+    it "should have a type" do
+      Vehicle.new.type.should == "Vehicle"
+    end
+
+    it "reports the same table name for both base and derived classes" do
+      Vehicle.table_name.should == Car.table_name
+      Vehicle.table_name.should == NuclearSubmarine.table_name
+    end
+  end
+
+  context '#count' do
+    it 'returns the number of documents in the table' do
+      document = Tweet.create(:tweet_id => 'x', :group => 'abc')
+      different = Tweet.create(:tweet_id => 'x', :group => 'xyz')
+
+      Tweet.count.should == 2
+    end
+  end
 end

data/spec/dynamoid/fields_spec.rb

@@ -36,13 +36,13 @@ describe "Dynamoid::Fields" do
     @address.updated_at.should_not be_nil
     @address.updated_at.class.should == DateTime
   end
-  
+
   context 'with a saved address' do
     before do
       @address = Address.create(:deliverable => true)
       @original_id = @address.id
     end
-    
+
     it 'should write an attribute correctly' do
       @address.write_attribute(:city, 'Chicago')
     end
@@ -75,6 +75,12 @@ describe "Dynamoid::Fields" do
       @address.id.should == @original_id
     end
 
+    it 'should update only created_at when no params are passed' do
+      @initial_updated_at = @address.updated_at
+      @address.update_attributes([])
+      @address.updated_at.should_not == @initial_updated_at
+    end
+
     it 'adds in dirty methods for attributes' do
       @address.city = 'Chicago'
       @address.save
@@ -85,7 +91,7 @@ describe "Dynamoid::Fields" do
     end
 
     it 'returns all attributes' do
-      Address.attributes.should == {:id=>{:type=>:string}, :created_at=>{:type=>:datetime}, :updated_at=>{:type=>:datetime}, :city=>{:type=>:string}, :options=>{:type=>:serialized}, :deliverable => {:type => :boolean}}
+      Address.attributes.should == {:id=>{:type=>:string}, :created_at=>{:type=>:datetime}, :updated_at=>{:type=>:datetime}, :city=>{:type=>:string}, :options=>{:type=>:serialized}, :deliverable => {:type => :boolean}, :lock_version => {:type => :integer}}
     end
   end
 
@@ -94,6 +100,18 @@ describe "Dynamoid::Fields" do
     Address.new city: ("Ten chars " * 6_600)
   end
 
+  context '.remove_attribute' do
+    subject { @address }
+    before(:each) do
+      Address.field :foobar
+      Address.remove_field :foobar
+    end
+
+    it('should not be in the attributes hash') { Address.attributes.should_not have_key(:foobar) }
+    it('removes the accessor') { should_not respond_to(:foobar)  }
+    it('removes the writer')   { should_not respond_to(:foobar=) }
+    it('removes the interrogative') { should_not respond_to(:foobar?) }
+  end
 
   context 'default values for fields' do
     before do
@@ -124,4 +142,15 @@ describe "Dynamoid::Fields" do
     end
   end
 
+  context 'single table inheritance' do
+    it "has only base class fields on the base class" do
+      Vehicle.attributes.keys.to_set.should == Set.new([:type, :description, :created_at, :updated_at, :id])
+    end
+
+    it "has only the base and derived fields on a sub-class" do
+      #Only NuclearSubmarines have torpedoes
+      Car.attributes.should_not have_key(:torpedoes)
+    end
+  end
+
 end

data/spec/dynamoid/finders_spec.rb

@@ -118,6 +118,7 @@ describe "Dynamoid::Finders" do
   end
 
   context 'find_all' do
+
     it 'should return a array of users' do
       users = (1..10).map { User.create }
       User.find_all(users.map(&:id)).should eq(users)
@@ -131,5 +132,16 @@ describe "Dynamoid::Finders" do
     it 'should return an empty array' do
       User.find_all([]).should eq([])
     end
+
+    it 'returns empty array when there are no results' do
+      Address.find_all('bad' + @address.id.to_s).should eq []
+    end
+
+    it 'passes options to the adapter' do
+      user_ids = [%w(1 red), %w(1 green)]
+      Dynamoid::Adapter.expects(:read).with(anything, user_ids, :consistent_read => true)
+      User.find_all(user_ids, :consistent_read => true)
+    end
+
   end
 end

data/spec/dynamoid/persistence_spec.rb

@@ -33,7 +33,25 @@ describe "Dynamoid::Persistence" do
 
     Dynamoid::Adapter.read("dynamoid_tests_addresses", @address.id)[:id].should == @address.id
   end
-
+  
+  it 'prevents concurrent writes to tables with a lock_version' do
+    @address.save!
+    a1 = @address
+    a2 = Address.find(@address.id)
+    
+    a1.city = 'Seattle'
+    a2.city = 'San Francisco'
+    
+    a1.save!
+    expect { a2.save! }.to raise_exception(Dynamoid::Errors::ConditionalCheckFailedException)
+  end
+  
+  configured_with 'partitioning' do
+    it 'raises an error when attempting to use optimistic locking' do
+      expect { address.save! }.to raise_exception
+    end
+  end
+  
   it 'assigns itself an id on save only if it does not have one' do
     @address.id = 'test123'
     @address.save
@@ -89,14 +107,14 @@ describe "Dynamoid::Persistence" do
     @address.options = (hash = {:x => [1, 2], "foobar" => 3.14})
     Address.undump(@address.send(:dump))[:options].should == hash
   end
-  
+
   [true, false].each do |bool|
     it "dumps a #{bool} boolean field" do
       @address.deliverable = bool
       Address.undump(@address.send(:dump))[:deliverable].should == bool
     end
   end
-  
+
   it 'raises on an invalid boolean value' do
     expect do
       @address.deliverable = true
@@ -142,7 +160,7 @@ describe "Dynamoid::Persistence" do
 
     lambda {Address.create(hash)}.should_not raise_error
   end
-  
+
   context 'create' do
     {
       Tweet   => ['with range',    { :tweet_id => 1, :group => 'abc' }],
@@ -151,11 +169,11 @@ describe "Dynamoid::Persistence" do
       it "checks for existence of an existing object #{fields[0]}" do
         t1 = clazz.new(fields[1])
         t2 = clazz.new(fields[1])
-      
+
         t1.save
         expect do
           t2.save!
-        end.to raise_exception AWS::DynamoDB::Errors::ConditionalCheckFailedException
+        end.to raise_exception Dynamoid::Errors::ConditionalCheckFailedException
       end
     end
   end
@@ -177,7 +195,7 @@ describe "Dynamoid::Persistence" do
         clazz.new(:deliverable => true) #undump is called here
       end.to raise_error(ArgumentError)
     end
-  
+
     it 'raises when dumping a column with an unknown field type' do
       doc = clazz.new
       doc.deliverable = true
@@ -186,13 +204,29 @@ describe "Dynamoid::Persistence" do
       end.to raise_error(ArgumentError)
     end
   end
-  
+
   context 'update' do
 
     before :each do
       @tweet = Tweet.create(:tweet_id => 1, :group => 'abc', :count => 5, :tags => ['db', 'sql'], :user_name => 'john')
     end
 
+    it 'runs before_update callbacks when doing #update' do
+      CamelCase.any_instance.expects(:doing_before_update).once.returns(true)
+
+      CamelCase.create(:color => 'blue').update do |t|
+        t.set(:color => 'red')
+      end
+    end
+
+    it 'runs after_update callbacks when doing #update' do
+      CamelCase.any_instance.expects(:doing_after_update).once.returns(true)
+
+      CamelCase.create(:color => 'blue').update do |t|
+        t.set(:color => 'red')
+      end
+    end
+
     it 'support add/delete operation on a field' do
       @tweet.update do |t|
         t.add(:count => 3)
@@ -222,6 +256,17 @@ describe "Dynamoid::Persistence" do
         end
       }.to raise_error(Dynamoid::Errors::ConditionalCheckFailedException)
     end
+    
+    it 'prevents concurrent saves to tables with a lock_version' do
+      @address.save!
+      a2 = Address.find(@address.id)
+      a2.update! { |a| a.set(:city => "Chicago") }
+      
+      expect do
+        @address.city = "Seattle"
+        @address.save!
+      end.to raise_error(Dynamoid::Errors::ConditionalCheckFailedException)
+    end
 
   end
 
@@ -233,4 +278,24 @@ describe "Dynamoid::Persistence" do
       }.should_not raise_error
     end
   end
+
+  context 'single table inheritance' do
+    let(:car) { Car.create(power_locks: false) }
+    let(:sub) { NuclearSubmarine.create(torpedoes: 5) }
+
+    it 'saves subclass objects in the parent table' do
+      c = car
+      Vehicle.find(c.id).should == c
+    end
+
+    it 'loads subclass item when querying the parent table' do
+      c = car
+      s = sub
+
+      Vehicle.all.to_a.tap { |v|
+        v.should include(c)
+        v.should include(s)
+      }
+    end
+  end
 end