dynamoid 0.7.1 → 1.0.0

data/spec/dynamoid/associations/has_many_spec.rb

@@ -1,42 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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

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

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