dynamoid-moda 0.7.1

data/spec/dynamoid/associations/has_many_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "Dynamoid::Associations::HasMany" do
+
+  before do
+    @magazine = Magazine.create
+    @user = User.create
+    @camel_case = CamelCase.create
+  end
+  
+  it 'determines equality from its records' do
+    @subscription = @magazine.subscriptions.create
+    
+    @magazine.subscriptions.should == @subscription
+  end
+
+  it 'determines target association correctly' do
+    @magazine.subscriptions.send(:target_association).should == :magazine
+    @user.books.send(:target_association).should == :owner
+    @camel_case.users.send(:target_association).should == :camel_case
+  end
+
+  it 'determins target class correctly' do
+    @magazine.subscriptions.send(:target_class).should == Subscription
+    @user.books.send(:target_class).should == Magazine
+  end
+  
+  it 'determines target attribute' do
+    @magazine.subscriptions.send(:target_attribute).should == :magazine_ids
+    @user.books.send(:target_attribute).should == :owner_ids
+  end
+  
+  it 'associates belongs_to automatically' do
+    @subscription = @magazine.subscriptions.create
+    
+    @subscription.magazine.should == @magazine
+
+    @magazine = @user.books.create
+    @magazine.owner.should == @user
+  end
+
+end

data/spec/dynamoid/associations/has_one_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "Dynamoid::Associations::HasOne" do
+
+  before do
+    @magazine = Magazine.create
+    @user = User.create
+    @camel_case = CamelCase.create
+  end
+  
+  it 'determines nil if it has no associated record' do
+    @magazine.sponsor.should be_nil
+  end
+
+  it 'determines target association correctly' do
+    @camel_case.sponsor.send(:target_association).should == :camel_case
+  end
+  
+  it 'returns only one object when associated' do
+    @magazine.sponsor.create
+    
+    @magazine.sponsor.should_not be_a_kind_of Array
+  end
+  
+  it 'delegates equality to its source record' do
+    @sponsor = @magazine.sponsor.create
+    
+    @magazine.sponsor.should == @sponsor
+  end
+  
+  it 'is equal from its target record' do
+    @sponsor = @magazine.sponsor.create
+    
+    @magazine.sponsor.should == @sponsor
+  end
+  
+  it 'associates belongs_to automatically' do
+    @sponsor = @magazine.sponsor.create
+    @sponsor.magazine.should == @magazine
+    @magazine.sponsor.should == @sponsor
+
+    @subscription = @user.monthly.create
+    @subscription.customer.should == @user
+  end
+end

data/spec/dynamoid/associations_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Associations" do
+  
+  before do
+    @magazine = Magazine.create
+  end
+  
+  it 'defines a getter' do
+    @magazine.should respond_to :subscriptions
+  end
+  
+  it 'defines a setter' do
+    @magazine.should respond_to :subscriptions=
+  end
+end

data/spec/dynamoid/config_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Config" do
+  
+  before(:each) do
+    Dynamoid::Config.reset_namespace
+  end
+  
+  after(:each) do
+    Dynamoid.config {|config| config.namespace = 'dynamoid_tests'}
+  end
+
+  it 'returns a namespace for non-Rails apps' do
+    Dynamoid::Config.namespace.should == 'dynamoid'
+  end
+  
+  it 'returns a namespace for Rails apps' do
+    class Rails; end
+    Rails.stubs(:application => stubs(:class => stubs(:parent_name => 'TestApp')))
+    Rails.stubs(:env => 'development')
+    Dynamoid::Config.send(:option, :namespace, :default => defined?(Rails) ? "dynamoid_#{Rails.application.class.parent_name}_#{Rails.env}" : "dynamoid")
+    
+    # TODO Make this return what we actually expect
+    Dynamoid::Config.namespace.should == "dynamoid_Mocha_development"
+  end
+  
+end

data/spec/dynamoid/criteria/chain_spec.rb

@@ -0,0 +1,210 @@
+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 '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]]
+
+    @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).to_a.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 '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
+
+    @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).to_a.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).to_a.should == [@tweet3]
+    end
+  end
+  
+  context 'destroy alls' 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 'destroys tweet with a range simple range query' do
+      @chain.query = { :tweet_id => "x" }
+      @chain.all.size.should == 2
+      @chain.destroy_all
+      @chain.consistent.all.size.should == 0
+    end
+
+    it 'deletes one specific tweet with range' do
+      @chain = Dynamoid::Criteria::Chain.new(Tweet)
+      @chain.query = { :tweet_id => "xx", :group => "two" }
+      @chain.all.size.should == 1
+      @chain.destroy_all
+      @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

data/spec/dynamoid/criteria_spec.rb

@@ -0,0 +1,75 @@
+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')
+    @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,57 @@
+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 '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')
+      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