dynamoid-moda 0.7.1

data/spec/dynamoid/identity_map_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::IdentityMap" do
+  before :each do
+    Dynamoid::Config.identity_map = true
+  end
+
+  after :each do
+    Dynamoid::Config.identity_map = false
+  end
+
+  context 'object identity' do
+    it 'maintains a single object' do
+      tweet = Tweet.create(:tweet_id => "x", :group => "one")
+      tweet1 = Tweet.where(:tweet_id => "x", :group => "one").first
+      tweet.should equal(tweet1)
+    end
+  end
+
+  context 'cache' do
+    it 'uses cache' do
+      tweet = Tweet.create(:tweet_id => "x", :group => "one")
+      Dynamoid::Adapter.expects(:read).never
+      tweet1 = Tweet.find_by_id("x", :range_key => "one")
+      tweet.should equal(tweet1)
+    end
+
+    it 'clears cache on delete' do
+      tweet = Tweet.create(:tweet_id => "x", :group => "one")
+      tweet.delete
+      Tweet.find_by_id("x", :range_key => "one").should be_nil
+    end
+  end
+
+  context 'clear' do
+    it 'clears the identiy map' do
+      Tweet.create(:tweet_id => "x", :group => "one")
+      Tweet.create(:tweet_id => "x", :group => "two")
+
+      Tweet.identity_map.size.should eq(2)
+      Dynamoid::IdentityMap.clear
+      Tweet.identity_map.size.should eq(0)
+    end
+  end
+end

data/spec/dynamoid/indexes/index_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "Dynamoid::Indexes::Index" do
+  
+  before do
+    @time = DateTime.now
+    @index = Dynamoid::Indexes::Index.new(User, [:password, :name], :range_key => :created_at)
+  end
+
+  it 'reorders keys alphabetically' do
+    @index.sort([:password, :name, :created_at]).should == [:created_at, :name, :password]
+  end
+  
+  it 'assigns itself hash keys' do
+    @index.hash_keys.should == [:name, :password]
+  end
+  
+  it 'assigns itself range keys' do
+    @index.range_keys.should == [:created_at]
+  end
+  
+  it 'reorders its name automatically' do
+    @index.name.should == [:created_at, :name, :password]
+  end
+  
+  it 'determines its own table name' do
+    @index.table_name.should == 'dynamoid_tests_index_user_created_ats_and_names_and_passwords'
+  end
+  
+  it 'raises an error if a field does not exist' do
+    lambda {@index = Dynamoid::Indexes::Index.new(User, [:password, :text])}.should raise_error(Dynamoid::Errors::InvalidField)
+  end
+  
+  it 'returns values for indexes' do
+    @index.values(:name => 'Josh', :password => 'test123', :created_at => @time).should == {:hash_value => 'Josh.test123', :range_value => @time.to_f}
+  end
+  
+  it 'ignores values for fields that do not exist' do
+    @index.values(:name => 'Josh', :password => 'test123', :created_at => @time, :email => 'josh@joshsymonds.com').should == {:hash_value => 'Josh.test123', :range_value => @time.to_f}
+  end
+  
+  it 'substitutes a blank string for a hash value that does not exist' do
+    @index.values(:name => 'Josh', :created_at => @time).should == {:hash_value => 'Josh.', :range_value => @time.to_f}
+  end
+  
+  it 'substitutes a blank string if both hash values do not exist' do
+    @index.values(:created_at => @time).should == {:hash_value => '.', :range_value => @time.to_f}
+  end
+  
+  it 'accepts values from an object instead of a hash' do
+    @user = User.new(:name => 'Josh', :password => 'test123', :created_at => @time)
+    
+    @index.values(@user).should == {:hash_value => 'Josh.test123', :range_value => @time.to_f}
+  end
+  
+  it 'accepts values from an object and returns changed values' do
+    @user = User.new(:name => 'Josh', :password => 'test123', :created_at => @time)
+    @user.name = 'Justin'
+    
+    @index.values(@user).should == {:hash_value => 'Justin.test123', :range_value => @time.to_f}
+  end
+  
+  it 'saves an object to the index it is associated with' do
+    @index = Dynamoid::Indexes::Index.new(User, :name)
+    @user = User.new(:name => 'Josh', :password => 'test123', :created_at => @time, :id => 'test123')
+    
+    @index.save(@user)
+    
+    Dynamoid::Adapter.read("dynamoid_tests_index_user_names", 'Josh')[:ids].should == Set['test123']
+  end
+  
+  it 'saves an object to the index it is associated with with a range' do
+    @index = Dynamoid::Indexes::Index.new(User, :name, :range_key => :last_logged_in_at)
+    @user = User.create(:name => 'Josh', :last_logged_in_at => @time)
+    
+    @index.save(@user)
+    
+    Dynamoid::Adapter.read("dynamoid_tests_index_user_last_logged_in_ats_and_names", 'Josh', :range_key => @time.to_f)[:ids].should == Set[@user.id]
+  end
+  
+  it 'deletes an object from the index it is associated with' do
+    @index = Dynamoid::Indexes::Index.new(User, :name)
+    @user = User.create(:name => 'Josh', :password => 'test123', :last_logged_in_at => @time, :id => 'test123')
+    
+    @index.save(@user)
+    @index.delete(@user)
+    
+    Dynamoid::Adapter.read("dynamoid_tests_index_user_names", 'Josh')[:ids].should be_nil
+  end
+  
+  it 'updates an object by removing it from its previous index and adding it to its new one' do
+    @index = Dynamoid::Indexes::Index.new(User, :name)
+    @user = User.create(:name => 'Josh', :password => 'test123', :last_logged_in_at => @time, :id => 'test123')
+
+    Dynamoid::Adapter.read("dynamoid_tests_index_user_names", 'Josh')[:ids].should == Set['test123']
+    Dynamoid::Adapter.read("dynamoid_tests_index_user_names", 'Justin').should be_nil
+
+    @user.update_attributes(:name => 'Justin')
+    
+    Dynamoid::Adapter.read("dynamoid_tests_index_user_names", 'Josh')[:ids].should be_nil
+    Dynamoid::Adapter.read("dynamoid_tests_index_user_names", 'Justin')[:ids].should == Set['test123']
+  end
+  
+end

data/spec/dynamoid/indexes_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Indexes" do
+  
+  it 'adds indexes to the index array' do
+    User.indexes.keys.should =~ [[:created_at], [:created_at, :name], [:email], [:email, :name], [:last_logged_in_at, :name], [:name]]
+  end
+  
+  it 'saves indexes to their tables' do
+    @user = User.new(:name => 'Josh')
+    
+    User.indexes.each {|k, v| v.expects(:save).with(@user).once.returns(true)}
+    
+    @user.save
+  end
+    
+  it 'deletes indexes when the object is destroyed' do
+    @user = User.create(:name => 'Josh')
+    
+    User.indexes.each {|k, v| v.expects(:delete).with(@user).once.returns(true)}
+    
+    @user.destroy
+  end
+
+end

data/spec/dynamoid/persistence_spec.rb

@@ -0,0 +1,301 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Persistence" do
+
+  before do
+    Random.stubs(:rand).with(Dynamoid::Config.partition_size).returns(0)
+    @address = Address.new
+  end
+
+  context 'without AWS keys' do
+    unless ENV['ACCESS_KEY'] && ENV['SECRET_KEY']
+      before do
+        Dynamoid::Adapter.delete_table(Address.table_name) if Dynamoid::Adapter.list_tables.include?(Address.table_name)
+      end
+
+      it 'creates a table' do
+        Address.create_table(:table_name => Address.table_name)
+
+        Dynamoid::Adapter.list_tables.should include 'dynamoid_tests_addresses'
+      end
+
+      it 'checks if a table already exists' do
+        Address.create_table(:table_name => Address.table_name)
+
+        Address.table_exists?(Address.table_name).should be_true
+        Address.table_exists?('crazytable').should be_false
+      end
+    end
+  end
+
+  it 'assigns itself an id on save' do
+    @address.save
+
+    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
+
+    Dynamoid::Adapter.read("dynamoid_tests_addresses", 'test123').should_not be_empty
+  end
+
+  it 'has a table name' do
+    Address.table_name.should == 'dynamoid_tests_addresses'
+  end
+
+  it 'saves indexes along with itself' do
+    @user = User.new(:name => 'Josh')
+
+    @user.expects(:save_indexes).once.returns(true)
+    @user.save
+  end
+
+  it 'deletes an item completely' do
+    @user = User.create(:name => 'Josh')
+    @user.destroy
+
+    Dynamoid::Adapter.read("dynamoid_tests_users", @user.id).should be_nil
+  end
+
+  it 'keeps string attributes as strings' do
+    @user = User.new(:name => 'Josh')
+    @user.send(:dump)[:name].should == 'Josh'
+  end
+
+  it 'dumps datetime attributes' do
+    @user = User.create(:name => 'Josh')
+    @user.send(:dump)[:name].should == 'Josh'
+  end
+
+  it 'dumps integer attributes' do
+    @subscription = Subscription.create(:length => 10)
+    @subscription.send(:dump)[:length].should == 10
+  end
+
+  it 'dumps set attributes' do
+    @subscription = Subscription.create(:length => 10)
+    @magazine = @subscription.magazine.create
+
+    @subscription.send(:dump)[:magazine_ids].should == Set[@magazine.id]
+  end
+
+  it 'handles nil attributes properly' do
+    Address.undump(nil).should be_a(Hash)
+  end
+
+  it 'dumps and undump a serialized field' 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
+      data = @address.send(:dump)
+      data[:deliverable] = 'foo'
+      Address.undump(data)
+    end.to raise_error(ArgumentError)
+  end
+
+  it 'loads a hash into a serialized field' do
+    hash = {foo: :bar}
+    Address.new(options: hash).options.should == hash
+  end
+
+  it 'loads attributes from a hash' do
+    @time = DateTime.now
+    @hash = {:name => 'Josh', :created_at => @time.to_f}
+
+    User.undump(@hash)[:name].should == 'Josh'
+    User.undump(@hash)[:created_at].to_f == @time.to_f
+  end
+
+  it 'runs the before_create callback only once' do
+    CamelCase.any_instance.expects(:doing_before_create).once.returns(true)
+
+    CamelCase.create
+  end
+
+  it 'runs after save callbacks when doing #create' do
+    CamelCase.any_instance.expects(:doing_after_create).once.returns(true)
+
+    CamelCase.create
+  end
+
+  it 'runs after save callbacks when doing #save' do
+    CamelCase.any_instance.expects(:doing_after_create).once.returns(true)
+
+    CamelCase.new.save
+  end
+
+  it 'works with a HashWithIndifferentAccess' do
+    hash = ActiveSupport::HashWithIndifferentAccess.new("city" => "Atlanta")
+
+    lambda {Address.create(hash)}.should_not raise_error
+  end
+
+  context 'create' do
+    {
+      Tweet   => ['with range',    { :tweet_id => 1, :group => 'abc' }],
+      Message => ['without range', { :message_id => 1, :text => 'foo', :time => DateTime.now }]
+    }.each_pair do |clazz, fields|
+      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 Dynamoid::Errors::ConditionalCheckFailedException
+      end
+    end
+  end
+
+  context 'unknown fields' do
+    let(:clazz) do
+      Class.new do
+        include Dynamoid::Document
+        table :name => :addresses
+
+        field :city
+        field :options, :serialized
+        field :deliverable, :bad_type_specifier
+      end
+    end
+
+    it 'raises when undumping a column with an unknown field type' do
+      expect 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
+      expect do
+        doc.dump
+      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)
+        t.delete(:tags => ['db'])
+      end
+
+      @tweet.count.should eq(8)
+      @tweet.tags.to_a.should eq(['sql'])
+    end
+
+    it 'checks the conditions on update' do
+      @tweet.update(:if => { :count => 5 }) do |t|
+        t.add(:count => 3)
+      end.should be_true
+
+      @tweet.count.should eq(8)
+
+      @tweet.update(:if => { :count => 5 }) do |t|
+        t.add(:count => 3)
+      end.should be_false
+
+      @tweet.count.should eq(8)
+
+      expect {
+        @tweet.update!(:if => { :count => 5 }) do |t|
+          t.add(:count => 3)
+        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
+
+  context 'delete' do
+    it 'deletes model with datetime range key' do
+      lambda {
+        msg = Message.create!(:message_id => 1, :time => DateTime.now, :text => "Hell yeah")
+        msg.destroy
+      }.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