dynamoid 0.7.1 → 1.0.0

data/spec/dynamoid/adapter_spec.rb

@@ -1,155 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Dynamoid::Adapter do
-  
-  def test_table; 'dynamoid_tests_TestTable'; end
-  let(:single_id){'123'}
-  let(:many_ids){%w(1 2)}
-
-  before(:all) do
-    described_class.create_table(test_table, :id) unless described_class.list_tables.include?(test_table)
-  end
-  
-  it 'extends itself automatically' do
-    lambda {described_class.list_tables}.should_not raise_error
-  end
-
-  it 'raises NoMethodError if we try a method that is not on the child' do
-    lambda {described_class.foobar}.should raise_error(NoMethodError)
-  end
-  
-  context 'without partioning' do
-    before(:all) do
-      @previous_value = Dynamoid::Config.partitioning
-      Dynamoid::Config.partitioning = false
-    end
-    
-    after(:all) do
-      Dynamoid::Config.partitioning = @previous_value
-    end
-    
-    it 'writes through the adapter' do
-      described_class.expects(:put_item).with(test_table, {:id => single_id}, nil).returns(true)
-      described_class.write(test_table, {:id => single_id})
-    end
-
-    it 'reads through the adapter for one ID' do
-      described_class.expects(:get_item).with(test_table, single_id, {}).returns(true)
-      described_class.read(test_table, single_id)
-    end
-
-    it 'reads through the adapter for many IDs' do
-      described_class.expects(:batch_get_item).with({test_table => many_ids}, {}).returns(true)
-      described_class.read(test_table, many_ids)
-    end
-
-    it 'delete through the adapter for one ID' do
-      described_class.expects(:delete_item).with(test_table, single_id, {}).returns(nil)
-      described_class.delete(test_table, single_id)
-    end
-
-    it 'deletes through the adapter for many IDs' do
-      described_class.expects(:batch_delete_item).with({test_table => many_ids}).returns(nil)
-      described_class.delete(test_table, many_ids)
-    end
-
-    it 'reads through the adapter for one ID and a range key' do
-      described_class.expects(:get_item).with(test_table, single_id, :range_key => 2.0).returns(true)
-      described_class.read(test_table, single_id, :range_key => 2.0)
-    end
-
-    it 'reads through the adapter for many IDs and a range key' do
-      described_class.expects(:batch_get_item).with({test_table => [['1', 2.0], ['2', 2.0]]}, {}).returns(true)
-      described_class.read(test_table, many_ids, :range_key => 2.0)
-    end
-
-    it 'deletes through the adapter for one ID and a range key' do
-      described_class.expects(:delete_item).with(test_table, single_id, :range_key => 2.0).returns(nil)
-      described_class.delete(test_table, single_id, :range_key => 2.0)
-    end
-
-    it 'deletes through the adapter for many IDs and a range key' do
-      described_class.expects(:batch_delete_item).with({test_table => [['1', 2.0], ['2', 2.0]]}).returns(nil)
-      described_class.delete(test_table, many_ids, :range_key => [2.0,2.0])
-    end
-  end
-  
-  configured_with 'partitioning' do
-    let(:partition_range){0...Dynamoid::Config.partition_size}
-
-    it 'writes through the adapter' do
-      Random.expects(:rand).with(Dynamoid::Config.partition_size).once.returns(0)
-      described_class.write(test_table, {:id => 'testid'})
-
-      described_class.get_item(test_table, 'testid.0')[:id].should == 'testid.0'
-      described_class.get_item(test_table, 'testid.0')[:updated_at].should_not be_nil
-    end
-  
-    it 'reads through the adapter for one ID' do
-      described_class.expects(:batch_get_item).with({test_table => partition_range.map{|n| "123.#{n}"}}, {}).returns({})
-      described_class.read(test_table, single_id)
-    end
-  
-    it 'reads through the adapter for many IDs' do
-      described_class.expects(:batch_get_item).with({test_table => partition_range.map{|n| "1.#{n}"} + partition_range.map{|n| "2.#{n}"}}, {}).returns({})
-      described_class.read(test_table, many_ids)
-    end
-    
-    it 'reads through the adapter for one ID and a range key' do
-      described_class.expects(:batch_get_item).with({test_table => partition_range.map{|n| ["123.#{n}", 2.0]}}, {}).returns({})
-      described_class.read(test_table, single_id, :range_key => 2.0)
-    end
-  
-    it 'reads through the adapter for many IDs and a range key' do
-      described_class.expects(:batch_get_item).with({test_table => partition_range.map{|n| ["1.#{n}", 2.0]} + partition_range.map{|n| ["2.#{n}", 2.0]}}, {}).returns({})
-      described_class.read(test_table, many_ids, :range_key => 2.0)
-    end
-  
-    it 'returns an ID with all partitions' do
-      described_class.id_with_partitions('1').should =~ partition_range.map{|n| "1.#{n}"}
-    end
-    
-    it 'returns an ID and range key with all partitions' do
-      described_class.id_with_partitions([['1', 1.0]]).should =~ partition_range.map{|n| ["1.#{n}", 1.0]}
-    end
-  
-    it 'returns a result for one partitioned element' do
-      @time = DateTime.now
-      @array =[{:id => '1.0', :updated_at => @time - 6.hours},
-               {:id => '1.1', :updated_at => @time - 3.hours},
-               {:id => '1.2', :updated_at => @time - 1.hour},
-               {:id => '1.3', :updated_at => @time - 6.hours},
-               {:id => '2.0', :updated_at => @time}]
-    
-      described_class.result_for_partition(@array,test_table).should =~ [{:id => '1', :updated_at => @time - 1.hour},
-                                                                           {:id => '2', :updated_at => @time}]
-    end
-    
-    it 'returns a valid original id and partition number' do
-      @id = "12345.387327.-sdf3"
-      @partition_number = "4"
-      described_class.get_original_id_and_partition("#{@id}.#{@partition_number}").should == [@id, @partition_number]
-    end
-    
-    it 'delete through the adapter for one ID' do
-      described_class.expects(:batch_delete_item).with(test_table => partition_range.map{|n| "123.#{n}"}).returns(nil)
-      described_class.delete(test_table, single_id)
-    end
-    
-    it 'deletes through the adapter for many IDs' do
-      described_class.expects(:batch_delete_item).with(test_table => partition_range.map{|n| "1.#{n}"} + partition_range.map{|n| "2.#{n}"}).returns(nil)
-      described_class.delete(test_table, many_ids)
-    end
-    
-    it 'deletes through the adapter for one ID and a range key' do
-      described_class.expects(:batch_delete_item).with(test_table => partition_range.map{|n| ["123.#{n}", 2.0]}).returns(nil)
-      described_class.delete(test_table, single_id, :range_key => 2.0)      
-    end
-    
-    it 'deletes through the adapter for many IDs and a range key' do
-      described_class.expects(:batch_delete_item).with(test_table => partition_range.map{|n| ["1.#{n}", 2.0]} + partition_range.map{|n| ["2.#{n}", 2.0]}).returns(nil)
-      described_class.delete(test_table, many_ids, :range_key => [2.0,2.0])
-    end
-  end
-
-end

data/spec/dynamoid/associations/association_spec.rb

@@ -1,194 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe "Dynamoid::Associations::Association" do
-
-  before do
-    Subscription.create_table
-    @magazine = Magazine.create
-  end
-
-  it 'returns an empty array if there are no associations' do
-    @magazine.subscriptions.should be_empty
-  end
-
-  it 'adds an item to an association' do
-    @subscription = Subscription.create
-
-    @magazine.subscriptions << @subscription
-    @magazine.subscriptions.size.should == 1
-    @magazine.subscriptions.should include @subscription
-  end
-
-  it 'deletes an item from an association' do
-    @subscription = Subscription.create
-    @magazine.subscriptions << @subscription
-
-    @magazine.subscriptions.delete(@subscription)
-    @magazine.subscriptions.size.should == 0
-  end
-
-  it 'creates an item from an association' do
-    @subscription = @magazine.subscriptions.create
-
-    @subscription.class.should == Subscription
-    @magazine.subscriptions.size.should == 1
-    @magazine.subscriptions.should include @subscription
-  end
-
-  it 'returns the number of items in the association' do
-    @magazine.subscriptions.create
-    @magazine.subscriptions.size.should == 1
-
-    @second = @magazine.subscriptions.create
-    @magazine.subscriptions.size.should == 2
-
-    @magazine.subscriptions.delete(@second)
-    @magazine.subscriptions.size.should == 1
-
-    @magazine.subscriptions = []
-    @magazine.subscriptions.size.should == 0
-  end
-
-  it 'assigns directly via the equals operator' do
-    @subscription = Subscription.create
-    @magazine.subscriptions = [@subscription]
-
-    @magazine.subscriptions.should == [@subscription]
-  end
-
-  it 'assigns directly via the equals operator and reflects to the target association' do
-    @subscription = Subscription.create
-    @magazine.subscriptions = [@subscription]
-
-    @subscription.magazine.should == @magazine
-  end
-
-  it 'does not assign reflection association if the reflection association does not exist' do
-    @sponsor = Sponsor.create
-
-    @subscription = @sponsor.subscriptions.create
-    @subscription.should_not respond_to :sponsor
-    @subscription.should_not respond_to :sponsors
-    @subscription.should_not respond_to :sponsors_ids
-    @subscription.should_not respond_to :sponsor_ids
-  end
-
-  it 'deletes all items from the association' do
-    @magazine.subscriptions << Subscription.create
-    @magazine.subscriptions << Subscription.create
-    @magazine.subscriptions << Subscription.create
-
-    @magazine.subscriptions.size.should == 3
-
-    @magazine.subscriptions = nil
-    @magazine.subscriptions.size.should == 0
-  end
-
-  it 'uses where inside an association and returns a result' do
-    @included_subscription = @magazine.subscriptions.create(:length => 10)
-    @unincldued_subscription = @magazine.subscriptions.create(:length => 8)
-
-    @magazine.subscriptions.where(:length => 10).all.should == [@included_subscription]
-  end
-
-  it 'uses where inside an association and returns an empty set' do
-    @included_subscription = @magazine.subscriptions.create(:length => 10)
-    @unincldued_subscription = @magazine.subscriptions.create(:length => 8)
-
-    @magazine.subscriptions.where(:length => 6).all.should be_empty
-  end
-
-  it 'includes enumerable' do
-    @subscription1 = @magazine.subscriptions.create
-    @subscription2 = @magazine.subscriptions.create
-    @subscription3 = @magazine.subscriptions.create
-
-    @magazine.subscriptions.collect(&:id).should =~ [@subscription1.id, @subscription2.id, @subscription3.id]
-  end
-
-  it 'works for camel-cased associations' do
-    @magazine.camel_cases.create.class.should == CamelCase
-  end
-
-  it 'destroys associations' do
-    @subscription = Subscription.new
-    @magazine.subscriptions.expects(:target).returns([@subscription])
-    @subscription.expects(:destroy)
-
-    @magazine.subscriptions.destroy_all
-  end
-
-  it 'deletes associations' do
-    @subscription = Subscription.new
-    @magazine.subscriptions.expects(:target).returns([@subscription])
-    @subscription.expects(:delete)
-
-    @magazine.subscriptions.delete_all
-  end
-
-  # TODO This test is broken using the AWS SDK adapter.
-  #it 'returns the first and last record when they exist' do
-  #  @subscription1 = @magazine.subscriptions.create
-  #  @subscription2 = @magazine.subscriptions.create
-  #  @subscription3 = @magazine.subscriptions.create
-  #
-  #  @magazine.subscriptions.instance_eval { [first, last] }.should == [@subscription1, @subscription3]
-  #end
-
-  it 'replaces existing associations when using the setter' do
-    @subscription1 = @magazine.subscriptions.create
-    @subscription2 = @magazine.subscriptions.create
-    @subscription3 = Subscription.create
-
-    @subscription1.reload.magazine_ids.should_not be_nil
-    @subscription2.reload.magazine_ids.should_not be_nil
-
-    @magazine.subscriptions = @subscription3
-    @magazine.subscriptions_ids.should == Set[@subscription3.id]
-
-    @subscription1.reload.magazine_ids.should be_nil
-    @subscription2.reload.magazine_ids.should be_nil
-    @subscription3.reload.magazine_ids.should == Set[@magazine.id]
-  end
-
-  it 'destroys all objects and removes them from the association' do
-    @subscription1 = @magazine.subscriptions.create
-    @subscription2 = @magazine.subscriptions.create
-    @subscription3 = @magazine.subscriptions.create
-
-    @magazine.subscriptions.destroy_all
-
-    @magazine.subscriptions.should be_empty
-    Subscription.all.should be_empty
-  end
-
-  it 'deletes all objects and removes them from the association' do
-    @subscription1 = @magazine.subscriptions.create
-    @subscription2 = @magazine.subscriptions.create
-    @subscription3 = @magazine.subscriptions.create
-
-    @magazine.subscriptions.delete_all
-
-    @magazine.subscriptions.should be_empty
-    Subscription.all.should be_empty
-  end
-
-  it 'delegates class to the association object' do
-    @magazine.sponsor.class.should == nil.class
-    @magazine.sponsor.create
-    @magazine.sponsor.class.should == Sponsor
-
-    @magazine.subscriptions.class.should == Array
-    @magazine.subscriptions.create
-    @magazine.subscriptions.class.should == Array
-  end
-
-  it 'loads association one time only' do
-    @sponsor = @magazine.sponsor.create
-    @magazine.sponsor.expects(:find_target).once.returns(@sponsor)
-
-    @magazine.sponsor.id
-    @magazine.sponsor.id
-  end
-
-end

data/spec/dynamoid/associations/belongs_to_spec.rb

@@ -1,71 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe "Dynamoid::Associations::BelongsTo" do
-  
-  context 'has many' do
-    before do
-      @subscription = Subscription.create
-      @camel_case = CamelCase.create
-    end
-  
-    it 'determines nil if it has no associated record' do
-      @subscription.magazine.should be_nil
-    end
-
-    it 'determines target association correctly' do
-      @camel_case.magazine.send(:target_association).should == :camel_cases
-    end
-
-  
-    it 'delegates equality to its source record' do
-      @magazine = @subscription.magazine.create
-
-      @subscription.magazine.should == @magazine
-    end
-  
-    it 'associates has_many automatically' do
-      @magazine = @subscription.magazine.create
-    
-      @magazine.subscriptions.should include @subscription
-
-      @magazine = Magazine.create
-      @user = @magazine.owner.create
-      @user.books.size.should == 1
-      @user.books.should include @magazine
-    end
-    
-    it 'behaves like the object it is trying to be' do
-      @magazine = @subscription.magazine.create
-
-      @subscription.magazine.update_attribute(:title, 'Test Title')
-
-      Magazine.first.title.should == 'Test Title'
-    end
-  end
-  
-  context 'has one' do
-    before do
-      @sponsor = Sponsor.create
-      @subscription = Subscription.create
-    end
-    
-    it 'determins nil if it has no associated record' do
-      @sponsor.magazine.should be_nil
-    end
-  
-    it 'delegates equality to its source record' do
-      @magazine = @sponsor.magazine.create
-    
-      @sponsor.magazine.should == @magazine
-    end
-  
-    it 'associates has_one automatically' do
-      @magazine = @sponsor.magazine.create
-      
-      @magazine.sponsor.should == @sponsor
-
-      @user = @subscription.customer.create
-      @user.monthly.should == @subscription
-    end
-  end
-end

data/spec/dynamoid/associations/has_and_belongs_to_many_spec.rb

@@ -1,47 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe "Dynamoid::Associations::HasAndBelongsToMany" do
-
-  before do
-    @subscription = Subscription.create
-    @camel_case = CamelCase.create
-  end
-  
-  it 'determines equality from its records' do
-    @user = @subscription.users.create
-    
-    @subscription.users.size.should == 1
-    @subscription.users.should include @user
-  end
-
-  it 'determines target association correctly' do
-    @subscription.users.send(:target_association).should == :subscriptions
-    @camel_case.subscriptions.send(:target_association).should == :camel_cases
-  end
-  
-  it 'determines target attribute' do
-    @subscription.users.send(:target_attribute).should == :subscriptions_ids
-  end
-  
-  it 'associates has_and_belongs_to_many automatically' do
-    @user = @subscription.users.create
-    
-    @user.subscriptions.size.should == 1
-    @user.subscriptions.should include @subscription
-    @subscription.users.size.should == 1
-    @subscription.users.should include @user
-
-    @user = User.create
-    @follower = @user.followers.create
-    @follower.following.should include @user
-    @user.followers.should include @follower
-  end
-  
-  it 'disassociates has_and_belongs_to_many automatically' do
-    @user = @subscription.users.create
-    
-    @subscription.users.delete(@user)
-    @subscription.users.size.should == 0
-    @user.subscriptions.size.should == 0
-  end
-end