adept_dynamoid 0.5.0.6

data/spec/dynamoid/criteria/chain_spec.rb

@@ -0,0 +1,140 @@
+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 == User.indexes[[:name]]
+
+    @chain.query = {:email => 'josh@joshsymonds.com'}
+    @chain.send(:index).should == User.indexes[[:email]]
+
+    @chain.query = {:name => 'Josh', :email => 'josh@joshsymonds.com'}
+    @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 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(:index_query).should == {:hash_value => 'Josh'}
+
+    @chain.query = {:email => 'josh@joshsymonds.com'}
+    @chain.send(:index_query).should == {:hash_value => 'josh@joshsymonds.com'}
+
+    @chain.query = {:name => 'Josh', :email => 'josh@joshsymonds.com'}
+    @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]
+
+    @chain.query = {:email => 'josh@joshsymonds.com'}
+    @chain.send(:records_with_index).should == [@user]
+
+    @chain.query = {:name => 'Josh', :email => 'josh@joshsymonds.com'}
+    @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]
+  end
+
+  it "doesn't crash if it finds a nil id in the index" do
+    @chain.query = {:name => 'Josh', "created_at.gt" => @time - 1.day}
+    Dynamoid::Adapter.expects(:query).
+                      with("dynamoid_tests_index_user_created_ats_and_names", kind_of(Hash)).
+                      returns([{ids: nil}, {ids: Set.new([42])}])
+    @chain.send(:ids_from_index).should == Set.new([42])
+  end
+
+  it 'defines each' do
+    @chain.query = {:name => 'Josh'}
+    @chain.each {|u| u.update_attribute(:name, 'Justin')}
+
+    User.find(@user.id).name.should == 'Justin'
+  end
+
+  it 'includes Enumerable' do
+    @chain.query = {:name => 'Josh'}
+
+    @chain.collect {|u| u.name}.should == ['Josh']
+  end
+
+  it 'finds range querys' do
+    @chain = Dynamoid::Criteria::Chain.new(Tweet)
+    @chain.query = { :tweet_id => 'test' }
+    @chain.send(:range?).should be_true
+
+    @chain.query = {:tweet_id => 'test', :group => 'xx'}
+    @chain.send(:range?).should be_true
+
+    @chain.query = { :group => 'xx' }
+    @chain.send(:range?).should be_false
+
+    @chain.query = { :group => 'xx', :msg => 'hai' }
+    @chain.send(:range?).should be_false
+  end
+
+  context 'range queries' do
+    before do
+      @tweet1 = Tweet.create(:tweet_id => "x", :group => "one")
+      @tweet2 = Tweet.create(:tweet_id => "x", :group => "two")
+      @tweet3 = Tweet.create(:tweet_id => "xx", :group => "two")
+      @chain = Dynamoid::Criteria::Chain.new(Tweet)
+    end
+
+    it 'finds tweets with a simple range query' do
+      @chain.query = { :tweet_id => "x" }
+      @chain.send(:records_with_range).size.should == 2
+      @chain.all.size.should == 2
+      @chain.limit(1).size.should == 1
+    end
+
+    it 'finds tweets with a start' do
+      @chain.query = { :tweet_id => "x" }
+      @chain.start(@tweet1)
+      @chain.all.should =~ [@tweet2]
+    end
+
+    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]
+    end
+  end
+
+end

data/spec/dynamoid/criteria_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Criteria" do
+  
+  before do
+    @user1 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+    @user2 = User.create(:name => 'Justin', :email => 'justin@joshsymonds.com')
+  end
+  
+  it 'finds first using where' do
+    User.where(:name => 'Josh').first.should == @user1
+  end
+  
+  it 'finds all using where' do
+    User.where(:name => 'Josh').all.should == [@user1]
+  end
+  
+  it 'returns all records' do
+    User.all.should =~ [@user1, @user2]
+    User.all.first.new_record.should be_false
+  end
+  
+  it 'returns empty attributes for where' do
+    Magazine.where(:name => 'Josh').all.should == []
+  end
+  
+  it 'returns empty attributes for all' do
+    Magazine.all.should == []
+  end
+  
+  it 'passes each to all members' do
+    User.each do |u|
+      u.id.should == @user1.id || @user2.id
+      u.new_record.should be_false
+    end
+  end
+
+  it 'returns n records' do
+    User.limit(1).size.should eq(1)
+    5.times { |i| User.create(:name => 'Josh', :email => 'josh_#{i}@joshsymonds.com') }
+    User.where(:name => 'Josh').all.size.should == 6
+    User.where(:name => 'Josh').limit(2).size.should == 2
+  end
+
+  # TODO This test is broken using the AWS SDK adapter.
+  #it 'start with a record' do
+  #  5.times { |i| User.create(:name => 'Josh', :email => 'josh_#{i}@joshsymonds.com') }
+  #  all = User.all
+  #  User.start(all[3]).all.should eq(all[4..-1])
+  #
+  #  all = User.where(:name => 'Josh').all
+  #  User.where(:name => 'Josh').start(all[3]).all.should eq(all[4..-1])
+  #end
+
+  it 'send consistent option to adapter' do
+    Dynamoid::Adapter.expects(:get_item).with { |table_name, key, options| options[:consistent_read] == true }
+    User.where(:name => 'x').consistent.first
+
+    Dynamoid::Adapter.expects(:query).with { |table_name, options| options[:consistent_read] == true }.returns([])
+    Tweet.where(:tweet_id => 'xx', :group => 'two').consistent.all
+
+    Dynamoid::Adapter.expects(:query).with { |table_name, options| options[:consistent_read] == false }.returns([])
+    Tweet.where(:tweet_id => 'xx', :group => 'two').all
+  end
+
+  it 'raises exception when consistent_read is used with scan' do
+    expect do
+      User.where(:password => 'password').consistent.first
+    end.to raise_error(Dynamoid::Errors::InvalidQuery)
+  end
+    
+end

data/spec/dynamoid/dirty_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Dynamoid::Dirty' do
+
+  context 'changes' do
+    it 'should be empty' do
+      tweet = Tweet.new
+      tweet.msg_changed?.should be_false
+    end
+
+    it 'should not be empty' do
+      tweet = Tweet.new(:tweet_id => "1", :group => 'abc')
+      tweet.changed?.should be_true
+      tweet.group_was.should be_nil
+    end
+
+    it 'should be empty when loaded from database' do
+      Tweet.create!(:tweet_id => "1", :group => 'abc')
+      tweet = Tweet.where(:tweet_id => "1", :group => 'abc').first
+      tweet.changed?.should be_false
+      tweet.group = 'abc'
+      tweet.reload
+      tweet.changed?.should be_false
+    end
+
+    it 'track changes after saves' do
+      tweet = Tweet.new(:tweet_id => "1", :group => 'abc')
+      tweet.save!
+      tweet.changed?.should be_false
+
+      tweet.user_name = 'xyz'
+      tweet.user_name_changed?.should be_true
+      tweet.user_name_was.should be_nil
+      tweet.save!
+
+      tweet.user_name_changed?.should be_false
+      tweet.user_name = 'abc'
+      tweet.user_name_was.should == 'xyz'
+    end
+
+    it 'clear changes on save' do
+      tweet = Tweet.new(:tweet_id => "1", :group => 'abc')
+      tweet.group = 'xyz'
+      tweet.group_changed?.should be_true
+      tweet.save!
+      tweet.group_changed?.should be_false
+    end
+  end
+end

data/spec/dynamoid/document_spec.rb

@@ -0,0 +1,118 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+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}
+  end
+
+  it 'responds to will_change! methods for all fields' do
+    @address = Address.new
+    @address.should respond_to(:id_will_change!)
+    @address.should respond_to(:options_will_change!)
+    @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}
+  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}
+  end
+
+  it 'allows interception of write_attribute on load' do
+    class Model
+      include Dynamoid::Document
+      field :city
+      def city=(value); self[:city] = value.downcase; end
+    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
+
+  it 'knows if a document exists or not' 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
+  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'
+  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'
+    Tweet.hash_key.should == :tweet_id
+    Tweet.read_capacity.should == 200
+    Tweet.write_capacity.should == 200
+  end
+end

data/spec/dynamoid/fields_spec.rb

@@ -0,0 +1,127 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Fields" do
+
+  before do
+    @address = Address.new
+  end
+
+  it 'declares read attributes' do
+    @address.city.should be_nil
+  end
+
+  it 'declares write attributes' do
+    @address.city = 'Chicago'
+    @address.city.should == 'Chicago'
+  end
+
+  it 'declares a query attribute' do
+    @address.city?.should be_false
+
+    @address.city = 'Chicago'
+
+    @address.city?.should be_true
+  end
+
+  it 'automatically declares id' do
+    lambda {@address.id}.should_not raise_error
+  end
+
+  it 'automatically declares and fills in created_at and updated_at' do
+    @address.save
+
+    @address = @address.reload
+    @address.created_at.should_not be_nil
+    @address.created_at.class.should == DateTime
+    @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
+      @original_id = @address.id
+    end
+
+    it 'should write an attribute correctly' do
+      @address.write_attribute(:city, 'Chicago')
+    end
+
+    it 'should write an attribute with an alias' do
+      @address[:city] = 'Chicago'
+    end
+
+    it 'should read a written attribute' do
+      @address.write_attribute(:city, 'Chicago')
+      @address.read_attribute(:city).should == 'Chicago'
+    end
+
+    it 'should read a written attribute with the alias' do
+      @address.write_attribute(:city, 'Chicago')
+      @address[:city].should == 'Chicago'
+    end
+
+    it 'should update all attributes' do
+      @address.expects(:save).once.returns(true)
+      @address.update_attributes(:city => 'Chicago')
+      @address[:city].should == 'Chicago'
+      @address.id.should == @original_id
+    end
+
+    it 'should update one attribute' do
+      @address.expects(:save).once.returns(true)
+      @address.update_attribute(:city, 'Chicago')
+      @address[:city].should == 'Chicago'
+      @address.id.should == @original_id
+    end
+
+    it 'adds in dirty methods for attributes' do
+      @address.city = 'Chicago'
+      @address.save
+
+      @address.city = 'San Francisco'
+
+      @address.city_was.should == 'Chicago'
+    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}}
+    end
+  end
+
+  it "gives a warning when setting a single value larger than the maximum item size" do
+    Dynamoid.logger.expects(:warn).with(regexp_matches(/city field has a length of 66000/))
+    Address.new city: ("Ten chars " * 6_600)
+  end
+
+
+  context 'default values for fields' do
+    before do
+      @clazz = Class.new do
+        include Dynamoid::Document
+
+        field :name, :string, :default => 'x'
+        field :uid, :integer, :default => lambda { 42 }
+
+        def self.name
+          'Document'
+        end
+      end
+
+
+      @doc = @clazz.new
+    end
+
+    it 'returns default value' do
+      @doc.name.should eq('x')
+      @doc.uid.should eq(42)
+    end
+
+    it 'should save default value' do
+      @doc.save!
+      @doc.reload.name.should eq('x')
+      @doc.uid.should eq(42)
+    end
+  end
+
+end