dynamoid 0.7.1 → 1.0.0

data/spec/dynamoid/document_spec.rb

@@ -1,180 +0,0 @@
-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, :deliverable => nil, :lock_version => 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, :deliverable => nil, :lock_version => 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, :deliverable => nil, :lock_version => 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
-    Address.exists?(:city => @address.city).should be_true
-    Address.exists?(:city => "does-not-exist").should be_false
-  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
-
-  context '.reload' do
-    let(:address){ Address.create }
-    let(:message){ Message.create({:text => 'Nice, supporting datetime range!', :time => Time.now.to_datetime}) }
-    let(:tweet){ tweet = Tweet.create(:tweet_id => 'x', :group => 'abc') }
-
-    it 'reflects persisted changes' do
-      address.update_attributes(:city => 'Chicago')
-      address.reload.city.should == 'Chicago'
-    end
-
-    it 'uses a :consistent_read' do
-      Tweet.expects(:find).with(tweet.hash_key, {:range_key => tweet.range_value, :consistent_read => true}).returns(tweet)
-      tweet.reload
-    end
-
-    it 'works with range key' do
-      tweet.reload.group.should == 'abc'
-    end
-
-    it 'works with a :datetime range key' do
-      expect { message.reload }.to_not raise_error(ArgumentError)
-    end
-  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
-
-  shared_examples 'it has equality testing and hashing' do
-    it 'is equal to itself' do
-      document.should == document
-    end
-
-    it 'is equal to another document with the same key(s)' do
-      document.should == same
-    end
-
-    it 'is not equal to another document with different key(s)' do
-      document.should_not == different
-    end
-
-    it 'is not equal to an object that is not a document' do
-      document.should_not == 'test'
-    end
-
-    it 'is not equal to nil' do
-      document.should_not == nil
-    end
-
-    it 'hashes documents with the keys to the same value' do
-      {document => 1}.should have_key(same)
-    end
-  end
-
-  context 'without a range key' do
-    it_behaves_like 'it has equality testing and hashing' do
-      let(:document) { Address.create(id: 123, city: 'Seattle') }
-      let(:different) { Address.create(id: 456, city: 'Seattle') }
-      let(:same) { Address.new(id: 123, city: 'Boston') }
-    end
-  end
-
-  context 'with a range key' do
-    it_behaves_like 'it has equality testing and hashing' do
-      let(:document){ Tweet.create(:tweet_id => 'x', :group => 'abc', :msg => 'foo') }
-      let(:different) { Tweet.create(:tweet_id => 'y', :group => 'abc', :msg => 'foo') }
-      let(:same) { Tweet.new(:tweet_id => 'x', :group => 'abc', :msg => 'bar') }
-    end
-
-    it 'is not equal to another document with the same hash key but a different range value' do
-      document = Tweet.create(:tweet_id => 'x', :group => 'abc')
-      different = Tweet.create(:tweet_id => 'x', :group => 'xyz')
-
-      document.should_not == different
-    end
-  end
-
-  context 'single table inheritance' do
-    it "should have a type" do
-      Vehicle.new.type.should == "Vehicle"
-    end
-
-    it "reports the same table name for both base and derived classes" do
-      Vehicle.table_name.should == Car.table_name
-      Vehicle.table_name.should == NuclearSubmarine.table_name
-    end
-  end
-
-  context '#count' do
-    it 'returns the number of documents in the table' do
-      document = Tweet.create(:tweet_id => 'x', :group => 'abc')
-      different = Tweet.create(:tweet_id => 'x', :group => 'xyz')
-
-      Tweet.count.should == 2
-    end
-  end
-end

data/spec/dynamoid/fields_spec.rb

@@ -1,156 +0,0 @@
-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(:deliverable => true)
-      @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 'should update only created_at when no params are passed' do
-      @initial_updated_at = @address.updated_at
-      @address.update_attributes([])
-      @address.updated_at.should_not == @initial_updated_at
-    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}, :deliverable => {:type => :boolean}, :lock_version => {:type => :integer}}
-    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 '.remove_attribute' do
-    subject { @address }
-    before(:each) do
-      Address.field :foobar
-      Address.remove_field :foobar
-    end
-
-    it('should not be in the attributes hash') { Address.attributes.should_not have_key(:foobar) }
-    it('removes the accessor') { should_not respond_to(:foobar)  }
-    it('removes the writer')   { should_not respond_to(:foobar=) }
-    it('removes the interrogative') { should_not respond_to(:foobar?) }
-  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
-
-  context 'single table inheritance' do
-    it "has only base class fields on the base class" do
-      Vehicle.attributes.keys.to_set.should == Set.new([:type, :description, :created_at, :updated_at, :id])
-    end
-
-    it "has only the base and derived fields on a sub-class" do
-      #Only NuclearSubmarines have torpedoes
-      Car.attributes.should_not have_key(:torpedoes)
-    end
-  end
-
-end

data/spec/dynamoid/finders_spec.rb

@@ -1,147 +0,0 @@
-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
-
-    it 'returns empty array when there are no results' do
-      Address.find_all('bad' + @address.id.to_s).should eq []
-    end
-
-    it 'passes options to the adapter' do
-      user_ids = [%w(1 red), %w(1 green)]
-      Dynamoid::Adapter.expects(:read).with(anything, user_ids, :consistent_read => true)
-      User.find_all(user_ids, :consistent_read => true)
-    end
-
-  end
-end