adept_dynamoid 0.5.0.6

data/spec/dynamoid/finders_spec.rb

@@ -0,0 +1,135 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Finders" do
+
+  before do
+    @address = Address.create(:city => 'Chicago')
+  end
+
+  it 'finds an existing address' do
+    found = Address.find(@address.id)
+
+    found.should == @address
+    found.city.should == 'Chicago'
+  end
+
+  it 'is not a new object' do
+    found = Address.find(@address.id)
+
+    found.new_record.should_not be_true
+  end
+
+  it 'returns nil when nothing is found' do
+    Address.find('1234').should be_nil
+  end
+
+  it 'finds multiple ids' do
+    @address2 = Address.create(:city => 'Illinois')
+
+    Address.find(@address.id, @address2.id).should include @address, @address2
+  end
+
+  it 'sends consistent option to the adapter' do
+    Dynamoid::Adapter.expects(:get_item).with { |table_name, key, options| options[:consistent_read] == true }
+    Address.find('x', :consistent_read => true)
+  end
+
+  context 'with users' do
+    before do
+      User.create_indexes
+    end
+
+    it 'finds using method_missing for attributes' do
+      array = Address.find_by_city('Chicago')
+
+      array.should == @address
+    end
+
+    it 'finds using method_missing for multiple attributes' do
+      @user = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+
+      array = User.find_all_by_name_and_email('Josh', 'josh@joshsymonds.com')
+
+      array.should == [@user]
+    end
+
+    it 'finds using method_missing for single attributes and multiple results' do
+      @user1 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+      @user2 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+
+      array = User.find_all_by_name('Josh')
+
+      array.size.should == 2
+      array.should include @user1
+      array.should include @user2
+    end
+
+    it 'finds using method_missing for multiple attributes and multiple results' do
+      @user1 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+      @user2 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+
+      array = User.find_all_by_name_and_email('Josh', 'josh@joshsymonds.com')
+
+      array.size.should == 2
+      array.should include @user1
+      array.should include @user2
+    end
+
+    it 'finds using method_missing for multiple attributes and no results' do
+      @user1 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+      @user2 = User.create(:name => 'Justin', :email => 'justin@joshsymonds.com')
+
+      array = User.find_all_by_name_and_email('Gaga','josh@joshsymonds.com')
+
+      array.should be_empty
+    end
+
+    it 'finds using method_missing for a single attribute and no results' do
+      @user1 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+      @user2 = User.create(:name => 'Justin', :email => 'justin@joshsymonds.com')
+
+      array = User.find_all_by_name('Gaga')
+
+      array.should be_empty
+    end
+
+    it 'should find on a query that is not indexed' do
+      @user = User.create(:password => 'Test')
+
+      array = User.find_all_by_password('Test')
+
+      array.should == [@user]
+    end
+
+    it 'should find on a query on multiple attributes that are not indexed' do
+      @user = User.create(:password => 'Test', :name => 'Josh')
+
+      array = User.find_all_by_password_and_name('Test', 'Josh')
+
+      array.should == [@user]
+    end
+
+    it 'should return an empty array when fields exist but nothing is found' do
+      array = User.find_all_by_password('Test')
+
+      array.should be_empty
+    end
+
+  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)
+    end
+
+    it 'should return a array of tweets' do
+      tweets = (1..10).map { |i| Tweet.create(:tweet_id => "#{i}", :group => "group_#{i}") }
+      Tweet.find_all(tweets.map { |t| [t.tweet_id, t.group] }).should eq(tweets)
+    end
+
+    it 'should return an empty array' do
+      User.find_all([]).should eq([])
+    end
+  end
+end

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,176 @@
+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 '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
+
+  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 'update' do
+
+    before :each do
+      @tweet = Tweet.create(:tweet_id => 1, :group => 'abc', :count => 5, :tags => ['db', 'sql'], :user_name => 'john')
+    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
+
+  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
+end