dm-mongo-adapter 0.2.0.pre3 → 0.6.0

data/spec/public/embedded_resource_spec.rb

@@ -1,220 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe DataMapper::Mongo::EmbeddedResource do
-  before(:all) do
-    class ::Address
-      include DataMapper::Mongo::EmbeddedResource
-      property :street, String
-      property :city,   String, :field => 'conurbation'
-    end
-
-    class ::AddressWithDefault
-      include DataMapper::Mongo::EmbeddedResource
-      property :city, String, :default => 'Rock Ridge'
-    end
-
-    class ::User
-      include DataMapper::Mongo::Resource
-      property :id, ObjectID
-      embeds 1, :address, :model => Address
-    end
-  end
-
-  #
-  # attributes
-  #
-
-  describe 'attributes' do
-    before(:all) do
-      @address = Address.new(:street => 'Main Street', :city => 'Rock Ridge')
-    end
-
-    it 'should return a Hash' do
-      @address.attributes.should be_kind_of(Hash)
-    end
-
-    it 'should use the property names when key_on=:name' do
-      @address.attributes(:name).should ==
-        { :street => 'Main Street', :city => 'Rock Ridge' }
-    end
-
-    it 'should use the field names when key_on=:field' do
-      @address.attributes(:field).should ==
-        { 'street' => 'Main Street', 'conurbation' => 'Rock Ridge' }
-    end
-
-    it 'should use the property instances when key_on=:property' do
-      @address.attributes(:property).should == {
-        Address.properties[:street] => 'Main Street',
-        Address.properties[:city]   => 'Rock Ridge'
-      }
-    end
-  end
-
-  #
-  # dirty?
-  #
-
-  describe '#dirty?' do
-    describe 'on a new embedded resource' do
-      it 'should return false' do
-        Address.new.should_not be_dirty
-      end
-
-      it 'should return true if an attribute has been changed' do
-        Address.new(:city => 'Rock Ridge').should be_dirty
-      end
-
-      it 'should return false if a changed attribute has been saved' do
-        address = Address.new(:city => 'Rock Ridge')
-
-        lambda { User.create(:address => address) }.should \
-          change(address, :dirty?).to(false)
-      end
-    end
-
-    describe 'on a persisted embedded resource' do
-      before(:each) do
-        user = User.create(:address => Address.new(:city => 'Rock Ridge'))
-        @address = user.address
-      end
-
-      it 'should return false when no changes have been made' do
-        @address.should_not be_dirty
-      end
-
-      it 'should return true if an attribute has been changed' do
-        @address.street = 'Main Street'
-        @address.should be_dirty
-      end
-
-      it 'should return false if a changed attribute has been saved' do
-        @address.street = 'Main Street'
-
-        lambda { @address.parent.save }.should \
-          change(@address, :dirty?).to(false)
-      end
-    end
-  end
-
-  #
-  # dirty_self?
-  #
-
-  describe '#dirty_self?' do
-    describe 'on a new embedded resource' do
-      it 'should return false if no changes have been made and no ' \
-         'properties have a default' do
-        Address.new.should_not be_dirty_self
-      end
-
-      it 'should return true if no changes have been made, but a property ' \
-         'has a default' do
-        AddressWithDefault.new.should be_dirty_self
-      end
-
-      it 'should return true if a change has been made' do
-        Address.new(:city => 'Rock Ridge').should be_dirty_self
-      end
-    end
-
-    describe 'on a persisited embedded resource' do
-      before(:each) do
-        user = User.create(:address => Address.new(:city => 'Rock Ridge'))
-        @address = user.address
-      end
-
-      it 'should return false if no changes have been made' do
-        @address.should_not be_dirty_self
-      end
-
-      it 'should return true if a change has been made' do
-        @address.street = 'Main Street'
-        @address.should be_dirty_self
-      end
-    end
-  end
-
-  #
-  # parent?
-  #
-
-  describe '#parent?' do
-    it 'should return true if the embedded resource has a parent' do
-      address = Address.new
-      address.parent = User.new
-      address.parent?.should be_true
-    end
-
-    it 'should return false if the embedded resource has no parent' do
-      Address.new.parent?.should be_false
-    end
-  end
-
-  #
-  # new?
-  #
-
-  describe '#new?' do
-    it 'should return false if it has been persisted' do
-      user = User.create(:address => Address.new(:city => 'Rock Ridge'))
-      user.address.should_not be_new
-    end
-
-    it 'should return true if its parent has not been persisted' do
-      user = User.new(:address => Address.new(:city => 'Rock Ridge'))
-      user.address.should be_new
-    end
-
-    it 'should return true if it has no parent' do
-      Address.new.should be_new
-    end
-  end
-
-  #
-  # saved?
-  #
-
-  describe '#saved?' do
-    it 'should return true if it has been persisted' do
-      user = User.create(:address => Address.new(:city => 'Rock Ridge'))
-      user.address.should be_saved
-    end
-
-    it 'should return false if its parent has not been persisted' do
-      user = User.new(:address => Address.new(:city => 'Rock Ridge'))
-      user.address.should_not be_saved
-    end
-
-    it 'should return false if it has no parent' do
-      Address.new.should_not be_saved
-    end
-  end
-
-  #
-  # save
-  #
-
-  describe '#save' do
-    it 'should raise MissingParentError if no parent is set' do
-      lambda { Address.new.save }.should raise_error(
-        DataMapper::Mongo::EmbeddedResource::MissingParentError)
-    end
-
-    it 'should clear the original attributes if the parent saved' do
-      user = User.new(:address => Address.new(:city => 'Rock Ridge'))
-
-      expectation = lambda { user.address.original_attributes.empty? }
-      lambda { user.address.save }.should change(&expectation).to(true)
-    end
-
-    it 'should not clear the original_attributes is the parent did not save' do
-      user = User.new(:address => Address.new(:city => 'Rock Ridge'))
-      user.stub!(:save).and_return(false)
-
-      expectation = lambda { user.address.original_attributes.empty? }
-      lambda { user.address.save }.should_not change(&expectation).to(true)
-    end
-  end
-
-end

data/spec/public/model/embedment_spec.rb

@@ -1,186 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe DataMapper::Mongo::Embedments do
-  # Removes the Engine constant, runs the block, then redefines the Engine
-  # class.
-  def without_engine_defined
-    old_engine = ::Engine
-    Object.send(:remove_const, :Engine) if defined?(::Engine)
-    yield
-    Object.send(:const_set, :Engine, old_engine)
-  end
-
-  before(:all) do
-    class ::Car
-      include DataMapper::Mongo::Resource
-      property :id, ObjectID
-      property :name, String
-    end
-
-    class ::Engine
-      include DataMapper::Mongo::EmbeddedResource
-      property :name, String
-    end
-
-    class ::Door
-      include DataMapper::Mongo::EmbeddedResource
-      property :name, String
-    end
-  end
-
-  def n
-    Car.n
-  end
-
-  it { Car.should respond_to(:embeds) }
-  it { Car.should respond_to(:embedments) }
-
-  describe '#embeds(1, ...)' do
-    before(:all) do
-      @model = Engine
-      @name  = :engine
-
-      Car.embeds(1, :engine)
-
-      @car = Car.new(:name => 'Ford')
-    end
-
-    it_should_behave_like 'A singular embedment reader'
-    it_should_behave_like 'A singular embedment writer'
-  end
-
-  describe '#embeds(n, ...)' do
-    before(:all) do
-      @model = Door
-      @name = :doors
-
-      Car.embeds(n, :doors)
-      @car = Car.new(:name => 'Ford')
-    end
-
-    it_should_behave_like 'A many embedment reader'
-    it_should_behave_like 'A many embedment writer'
-  end
-
-  describe '#embeds(n, :through ...)' do
-    it 'should raise an ArgumentError' do
-      pending ':through option not supported on embedments'
-    end
-  end
-
-  describe '#embeds(1..4)' do
-    before(:all) do
-      @model = Door
-      @name = :doors
-
-      Car.embeds(1..4, :doors)
-      @car = Car.new(:name => 'Ford')
-    end
-
-    it_should_behave_like 'A many embedment reader'
-    it_should_behave_like 'A many embedment writer'
-  end
-
-  describe '#embeds' do
-    describe 'when inferring the model from the name' do
-      it 'should set the relationship target model' do
-        Car.embeds(1, :engine)
-        Car.embedments[:engine].target_model.should == Engine
-      end
-
-      it 'should set the relationship target model when it is not defined' do
-        without_engine_defined do
-          Car.embeds(1, :engine)
-        end
-
-        Car.embedments[:engine].target_model.should == Engine
-      end
-    end
-
-    describe 'when the third argument is a model' do
-      it 'should set the relationship target model' do
-        Car.embeds(1, :engine, Engine)
-        Car.embedments[:engine].target_model.should == Engine
-      end
-    end
-
-    describe 'when the third argument is a string' do
-      it 'should set the relationship target model' do
-        without_engine_defined do
-          Car.embeds(1, :engine, 'Engine')
-        end
-
-        Car.embedments[:engine].target_model.should == Engine
-      end
-
-      it 'should raise NameError when given an invalid string' do
-        Car.embeds(1, :engine, 'DoesNotExist')
-        running = lambda { Car.embedments[:engine].target_model }
-        running.should raise_error(NameError)
-      end
-    end
-
-    describe 'when a :model option is given' do
-      it 'should set the relationship target model when given a string' do
-        without_engine_defined do
-          Car.embeds(1, :engine, :model => 'Engine')
-        end
-
-        Car.embedments[:engine].target_model.should == Engine
-      end
-
-      it 'should raise NameError when given an invalid string' do
-        Car.embeds(1, :engine, :model => 'DoesNotExist')
-        running = lambda { Car.embedments[:engine].target_model }
-        running.should raise_error(NameError)
-      end
-
-      it 'should set the relationship target model when given a model' do
-        Car.embeds(1, :engine, :model => Engine)
-        Car.embedments[:engine].target_model.should == Engine
-      end
-    end
-
-    describe 'when no model is given' do
-      it 'should raise NameError' do
-        Car.embeds(1, :does_not_exist)
-        running = lambda { Car.embedments[:engine].target_model }
-        running.should raise_error(NameError)
-      end
-    end
-
-    it 'should raise an exception if a :through option is given' do
-      running = lambda { Car.embeds(1, Engine, :through => :engines) }
-      running.should raise_error(ArgumentError)
-    end
-
-    it 'should raise an exception if a :remote_name option is given' do
-      running = lambda { Car.embeds(1, Engine, :remote_name => :engines) }
-      running.should raise_error(ArgumentError)
-    end
-
-    it 'should raise an exception if a :via option is given' do
-      running = lambda { Car.embeds(1, Engine, :via => :engines) }
-      running.should raise_error(ArgumentError)
-    end
-
-    it 'should raise an exception if a :inverse option is given' do
-      running = lambda { Car.embeds(1, Engine, :inverse => :parent) }
-      running.should raise_error(ArgumentError)
-    end
-
-    it 'should raise an exception if a :parent_key option is given' do
-      running = lambda { Car.embeds(1, Engine, :parent_key => :id) }
-      running.should raise_error(ArgumentError)
-    end
-
-    it 'should raise an exception if the cardinality is not understood' do
-      lambda { Car.embeds(n..n, :doors) }.should raise_error(ArgumentError)
-    end
-
-    it 'should raise an exception if the minimum constraint is larger than the maximum' do
-      lambda { Car.embeds(2..1, :doors) }.should raise_error(ArgumentError)
-    end
-  end
-
-end

data/spec/public/shared/model_embedments_spec.rb

@@ -1,338 +0,0 @@
-# The share specs contained herein are very slightly modified versions of
-# those found in dm-core/spec/public/model/relationship_spec.rb
-
-share_examples_for 'A singular embedment reader' do
-  it { @car.should respond_to(@name) }
-
-  describe 'reader' do
-    describe 'when there is no associated resource' do
-      it 'should return nil when there is no query' do
-        @car.__send__(@name).should be_nil
-      end
-
-      it 'should return nil when there is a query' do
-        @car.__send__(@name, :name => '__nothing__').should be_nil
-      end
-    end # when there is no associated resource
-
-    describe 'when there is an associated resource' do
-      before(:all) do
-        @expected = @model.new
-        @car.__send__("#{@name}=", @expected)
-      end
-
-      describe 'without a query' do
-        it 'should return an EmbeddedResource' do
-          returned = @car.__send__(@name)
-          returned.should be_kind_of(DataMapper::Mongo::EmbeddedResource)
-        end
-
-        it 'should return the correct EmbeddedResource' do
-          @car.__send__(@name).should == @expected
-        end
-      end
-
-      describe 'with a query' do
-        it 'should return a EmbeddedResource' do
-          returned = @car.__send__(@name, :name => @expected.name)
-          returned.should be_kind_of(DataMapper::Mongo::EmbeddedResource)
-        end
-
-        it 'should return the correct EmbeddedResource' do
-          @car.__send__(@name, :name => @expected.name).should == @expected
-        end
-      end
-    end # when there is an associated resource
-
-  end # reader
-end # A singular embedment reader
-
-share_examples_for 'A singular embedment writer' do
-  it { @car.should respond_to("#{@name}=") }
-
-  describe 'writer' do
-    describe 'when setting the wrong kind of target' do
-      it 'should raise an ArgumentError' do
-        calling = lambda { @car.__send__("#{@name}=", Object.new) }
-        calling.should raise_error(ArgumentError)
-      end
-    end
-
-    describe 'when setting an EmbeddedResource' do
-      before(:all) do
-        @expected = @model.new
-        @return = @car.__send__("#{@name}=", @expected)
-      end
-
-      it 'should return the expected EmbeddedResource' do
-        @return.should equal(@expected)
-      end
-
-      it 'should set the EmbeddedResource' do
-        @car.__send__(@name).should equal(@expected)
-      end
-
-      it 'should relate the associated EmbeddedResource' do
-        @expected.parent.should == @car
-      end
-
-      it 'should persist the Resource' do
-        @car.save.should be_true
-        @car.model.get(*@car.key).__send__(@name).should == @expected
-      end
-    end # when setting an EmbeddedResource
-
-    describe 'when setting a Hash' do
-      before(:all) do
-        @expected = @model.new(:name => 'Name')
-        @return = @car.__send__("#{@name}=", { :name => 'Name' })
-      end
-
-      it 'should return the expected EmbeddedResource' do
-        @return.should == @expected
-      end
-
-      it 'should set the EmbeddedResource' do
-        @car.__send__(@name).should equal(@return)
-      end
-
-      it 'should relate the associated EmbeddedResource' do
-        @car.__send__(@name).parent.should == @car
-      end
-
-      it 'should persist the Resource' do
-        @car.save.should be_true
-        @car.model.get(*@car.key).__send__(@name).should == @expected
-      end
-    end # when setting a Hash
-
-    describe 'when setting nil' do
-      before(:all) do
-        @car.__send__("#{@name}=", @model.new)
-        @return = @car.__send__("#{@name}=", nil)
-      end
-
-      it 'should return nil' do
-        @return.should be_nil
-      end
-
-      it 'should set nil' do
-        @car.__send__(@name).should be_nil
-      end
-
-      it 'should persist as nil' do
-        @car.save.should be_true
-        @car.model.get(*@car.key).__send__(@name).should be_nil
-      end
-    end # when setting nil
-
-    describe 'when changing the EmbeddedResource' do
-      before(:all) do
-        @car.__send__("#{@name}=", @model.new)
-        @return = @car.__send__("#{@name}=", @expected = @model.new)
-      end
-
-      it 'should return the expected EmbeddedResource' do
-        @return.should equal(@expected)
-      end
-
-      it 'should set the EmbeddedResource' do
-        @car.__send__(@name).should equal(@return)
-      end
-
-      it 'should relate the associated EmbeddedResource' do
-        @car.__send__(@name).parent.should == @car
-      end
-
-      it 'should persist the Resource' do
-        @car.save.should be_true
-        @car.model.get(*@car.key).__send__(@name).should == @expected
-      end
-    end # when changing the EmbeddedResource
-
-  end # writer
-end # A singular embedment writer
-
-share_examples_for 'A many embedment reader' do
-  it { @car.should respond_to(@name) }
-
-  describe 'reader' do
-    describe 'when there are no child resources and the source is saved' do
-      before(:all) do
-        @car.save.should be_true
-        @return = @car.__send__(@name)
-      end
-
-      it 'should return a Collection' do
-        @return.should be_kind_of(
-          DataMapper::Mongo::Embedments::OneToMany::Collection)
-      end
-
-      it 'should return an empty Collection' do
-        @return.should be_empty
-      end
-    end # when there is no child resource and the source is saved
-
-    describe 'when there are no child resources and the source is not saved' do
-      before(:all) do
-        @return = @car.__send__(@name)
-      end
-
-      it 'should return a Collection' do
-        @return.should be_kind_of(
-          DataMapper::Mongo::Embedments::OneToMany::Collection)
-      end
-
-      it 'should return an empty Collection' do
-        @return.should be_empty
-      end
-    end # when there is no child resource and the source is not save
-
-    describe 'when there is a child resource' do
-      before(:all) do
-        @expected = @model.new
-        @car.__send__("#{@name}=", [ @expected ])
-        @return = @car.__send__(@name)
-      end
-
-      it 'should return a Collection' do
-        @return.should be_kind_of(
-          DataMapper::Mongo::Embedments::OneToMany::Collection)
-      end
-
-      it 'should return the expected resources' do
-        @return.should == [ @expected ]
-      end
-    end # when there is a child resource
-
-  end # reader
-end # A many embedment reader
-
-share_examples_for 'A many embedment writer' do
-  it { @car.should respond_to("#{@name}=") }
-
-  describe 'writer' do
-    describe 'when setting an Array of the wrong kind of target' do
-      it 'should raise an ArgumentError' do
-        calling = lambda { @car.__send__("#{@name}=", [Object.new]) }
-        calling.should raise_error(ArgumentError)
-      end
-    end # when setting an Array of the wrong kind of target
-
-    describe 'when setting an Array of EmbeddedResources' do
-      before(:all) do
-        @expected = [ @model.new ]
-        @return = @car.__send__("#{@name}=", @expected)
-      end
-
-      it 'should return the expected Collection' do
-        @return.should == @expected
-      end
-
-      it 'should set the Collection' do
-        @car.__send__(@name).should == @expected
-        @car.__send__(@name).zip(@expected) do |value, expected|
-          value.should equal(expected)
-        end
-      end
-
-      it 'should relate the associated Collection' do
-        @expected.each { |resource| resource.parent.should == @car }
-      end
-
-      it 'should persist the Collection' do
-        @car.save.should be_true
-        @car.model.get(*@car.key).__send__(@name).should == @expected
-      end
-
-      it 'should persist the associated EmbeddedResources' do
-        @car.save.should be_true
-        @expected.each { |resource| resource.should be_saved }
-      end
-    end # when setting an Array of EmbeddedResources
-
-    describe 'when setting an Array of Hashes' do
-      before(:all) do
-        @expected = [ @model.new(:name => 'Name') ]
-        @return = @car.__send__("#{@name}=", [{ :name => 'Name' }])
-      end
-
-      it 'should return the expected Collection' do
-        @return.should == @expected
-      end
-
-      it 'should set the Collection' do
-        @car.__send__(@name).should == @expected
-        @car.__send__(@name).zip(@expected) do |value, expected|
-          value.should == expected
-        end
-      end
-
-      it 'should relate the associated Collection' do
-        @return.each { |resource| resource.parent.should == @car }
-      end
-
-      it 'should persist the Collection' do
-        @car.save.should be_true
-        @car.model.get(*@car.key).__send__(@name).should == @expected
-      end
-
-      it 'should persist the associated EmbeddedResources' do
-        @car.save.should be_true
-        @return.each { |resource| resource.should be_saved }
-      end
-    end # when setting an Array of Hashes
-
-    describe 'when setting an empty collection' do
-      before :all do
-        @car.__send__("#{@name}=", [ @model.new ])
-        @return = @car.__send__("#{@name}=", [])
-      end
-
-      it 'should return a Collection' do
-        @return.should be_kind_of(
-          DataMapper::Mongo::Embedments::OneToMany::Collection)
-      end
-
-      it 'should set a empty Collection' do
-        @car.__send__(@name).should be_empty
-      end
-
-      it 'should persist as an empty collection' do
-        @car.save.should be_true
-        @car.model.get(*@car.key).__send__(@name).should be_empty
-      end
-    end # when setting an empty collection
-
-    describe 'when changing an associated collection' do
-      before(:all) do
-        @car.__send__("#{@name}=", [ @model.new ])
-        @expected = [ @model.new ]
-        @return = @car.__send__("#{@name}=", @expected)
-      end
-
-      it 'should return the expected Resource' do
-        @return.should == @expected
-      end
-
-      it 'should set the Resource' do
-        @car.__send__(@name).should == @expected
-      end
-
-      it 'should relate the associated Resource' do
-        @expected.each { |resource| resource.parent.should == @car }
-      end
-
-      it 'should persist the Resource' do
-        @car.save.should be_true
-        @car.model.get(*@car.key).__send__(@name).should == @expected
-      end
-
-      it 'should persist the associated Resource' do
-        @car.save.should be_true
-        @expected.each { |resource| resource.should be_saved }
-      end
-    end # when setting an associated collection
-
-  end #writer
-end # A many embedment writer