ghost_dm-core 1.3.0.beta

data/spec/public/model/hook_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+describe DataMapper::Model::Hook do
+  before :all do
+    class ::ModelHookSpecs
+      include DataMapper::Resource
+
+      property :id, Serial
+      property :value, Integer, :required => true, :default => 1
+
+      def an_instance_method
+      end
+    end
+
+    class ::ModelHookSpecsSubclass < ModelHookSpecs; end
+
+    DataMapper.finalize
+  end
+
+  before :all do
+    @resource = ModelHookSpecs.new
+  end
+
+  describe '#before' do
+    describe 'an instance method' do
+      before do
+        @hooks = hooks = []
+        ModelHookSpecs.before(:an_instance_method) { hooks << :before_instance_method }
+
+        @resource.an_instance_method
+      end
+
+      it 'should execute before instance method hook' do
+        @hooks.should == [ :before_instance_method ]
+      end
+    end
+
+    describe 'save' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.before(:save) { hooks << :before_save }
+
+          @resource.save
+        end
+
+        it 'should execute before save hook' do
+          @hooks.should == [ :before_save ]
+        end
+      end
+    end
+
+    describe 'create' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.before(:create) { hooks << :before_create }
+
+          @resource.save
+        end
+
+        it 'should execute before create hook' do
+          @hooks.should == [ :before_create ]
+        end
+      end
+    end
+
+    describe 'update' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.before(:update) { hooks << :before_update }
+
+          @resource.save
+          @resource.update(:value => 2)
+        end
+
+        it 'should execute before update hook' do
+          @hooks.should == [ :before_update ]
+        end
+      end
+    end
+
+    describe 'destroy' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.before(:destroy) { hooks << :before_destroy }
+
+          @resource.save
+          @resource.destroy
+        end
+
+        it 'should execute before destroy hook' do
+          @hooks.should == [ :before_destroy ]
+        end
+      end
+    end
+
+    describe 'with an inherited hook' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.before(:an_instance_method) { hooks << :inherited_hook }
+        end
+
+        it 'should execute inherited hook' do
+          ModelHookSpecsSubclass.new.an_instance_method
+          @hooks.should == [ :inherited_hook ]
+        end
+      end
+    end
+
+    describe 'with a hook declared in the subclasss' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecsSubclass.before(:an_instance_method) { hooks << :hook }
+        end
+
+        it 'should execute hook' do
+          ModelHookSpecsSubclass.new.an_instance_method
+          @hooks.should == [ :hook ]
+        end
+
+        it 'should not alter hooks in the parent class' do
+          @hooks.should be_empty
+          ModelHookSpecs.new.an_instance_method
+          @hooks.should == []
+        end
+      end
+    end
+  end
+
+  describe '#after' do
+    describe 'an instance method' do
+      before do
+        @hooks = hooks = []
+        ModelHookSpecs.after(:an_instance_method) { hooks << :after_instance_method }
+
+        @resource.an_instance_method
+      end
+
+      it 'should execute after instance method hook' do
+        @hooks.should == [ :after_instance_method ]
+      end
+    end
+
+    describe 'save' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.after(:save) { hooks << :after_save }
+
+          @resource.save
+        end
+
+        it 'should execute after save hook' do
+          @hooks.should == [ :after_save ]
+        end
+      end
+    end
+
+    describe 'create' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.after(:create) { hooks << :after_create }
+
+          @resource.save
+        end
+
+        it 'should execute after create hook' do
+          @hooks.should == [ :after_create ]
+        end
+      end
+    end
+
+    describe 'update' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.after(:update) { hooks << :after_update }
+
+          @resource.save
+          @resource.update(:value => 2)
+        end
+
+        it 'should execute after update hook' do
+          @hooks.should == [ :after_update ]
+        end
+      end
+    end
+
+    describe 'destroy' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.after(:destroy) { hooks << :after_destroy }
+
+          @resource.save
+          @resource.destroy
+        end
+
+        it 'should execute after destroy hook' do
+          @hooks.should == [ :after_destroy ]
+        end
+      end
+    end
+
+    describe 'with an inherited hook' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.after(:an_instance_method) { hooks << :inherited_hook }
+        end
+
+        it 'should execute inherited hook' do
+          ModelHookSpecsSubclass.new.an_instance_method
+          @hooks.should == [ :inherited_hook ]
+        end
+      end
+    end
+
+    describe 'with a hook declared in the subclasss' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecsSubclass.after(:an_instance_method) { hooks << :hook }
+        end
+
+        it 'should execute hook' do
+          ModelHookSpecsSubclass.new.an_instance_method
+          @hooks.should == [ :hook ]
+        end
+
+        it 'should not alter hooks in the parent class' do
+          @hooks.should be_empty
+          ModelHookSpecs.new.an_instance_method
+          @hooks.should == []
+        end
+      end
+    end
+
+  end
+end

data/spec/public/model/property_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+shared_examples_for "a correct property declaration" do
+  it 'should define a name accessor' do
+    @model.should_not be_method_defined(@property_name)
+    subject
+    @model.should be_method_defined(@property_name)
+  end
+
+  it 'should define a name= mutator' do
+    @model.should_not be_method_defined(:"#{@property_name}=")
+    subject
+    @model.should be_method_defined(:"#{@property_name}=")
+  end
+end
+
+describe DataMapper::Model::Property do
+  before do
+    Object.send(:remove_const, :ModelPropertySpecs) if defined?(ModelPropertySpecs)
+    class ::ModelPropertySpecs
+      include DataMapper::Resource
+
+      property :id, Serial
+    end
+    DataMapper.finalize
+  end
+
+  describe '#property' do
+    context "using default repository" do
+      before do
+        Object.send(:remove_const, :UserDefault) if defined?(::UserDefault)
+
+        class ::UserDefault
+          include DataMapper::Resource
+          property :id, Serial
+        end
+
+        @model         = ::UserDefault
+        @property_name = :name
+      end
+
+      subject do
+        ::UserDefault.property(:name, String)
+      end
+
+      it_should_behave_like "a correct property declaration"
+    end
+
+    context "using alternate repository" do
+      before do
+        Object.send(:remove_const, :UserAlternate) if defined?(::UserAlternate)
+
+        class ::UserAlternate
+          include DataMapper::Resource
+          property :id, Serial
+          repository(:alternate) { property :age, Integer }
+        end
+
+        @model         = UserAlternate
+        @property_name = :alt_name
+      end
+
+      subject do
+        ::UserAlternate.property(:alt_name, String)
+      end
+
+      it_should_behave_like "a correct property declaration"
+    end
+
+    it 'should raise an exception if the method exists' do
+      lambda {
+        ModelPropertySpecs.property(:key, String)
+      }.should raise_error(ArgumentError, '+name+ was :key, which cannot be used as a property name since it collides with an existing method or a query option')
+    end
+
+    it 'should raise an exception if the property is boolean and method with question mark already exists' do
+      lambda {
+        ModelPropertySpecs.property(:destroyed, DataMapper::Property::Boolean)
+      }.should raise_error(ArgumentError, '+name+ was :destroyed, which cannot be used as a property name since it collides with an existing method or a query option')
+    end
+
+    it 'should raise an exception if the name is the same as one of the query options' do
+      lambda {
+        ModelPropertySpecs.property(:order, String)
+      }.should raise_error(ArgumentError, '+name+ was :order, which cannot be used as a property name since it collides with an existing method or a query option')
+    end
+  end
+end

data/spec/public/model/relationship_spec.rb

@@ -0,0 +1,1040 @@
+require 'spec_helper'
+
+share_examples_for 'it creates a one accessor' do
+  describe 'accessor' do
+    describe 'when there is no associated resource' do
+      describe 'without a query' do
+        before :all do
+          @return = @car.__send__(@name)
+        end
+
+        it 'should return nil' do
+          @return.should be_nil
+        end
+      end
+
+      describe 'with a query' do
+        before :all do
+          @return = @car.__send__(@name, :id => 99)
+        end
+
+        it 'should return nil' do
+          @return.should be_nil
+        end
+      end
+    end
+
+    describe 'when there is an associated resource' do
+      before :all do
+        @expected = @model.new
+        @car.__send__("#{@name}=", @expected)
+      end
+
+      describe 'without a query' do
+        before :all do
+          @return = @car.__send__(@name)
+        end
+
+        it 'should return a Resource' do
+          @return.should be_kind_of(DataMapper::Resource)
+        end
+
+        it 'should return the expected Resource' do
+          @return.should equal(@expected)
+        end
+      end
+
+      describe 'with a query' do
+        before :all do
+          @car.save  # save @car and @expected to set @expected.id
+
+          @expected.id.should_not be_nil
+
+          @return = @car.__send__(@name, :id => @expected.id)
+        end
+
+        it 'should return a Resource' do
+          @return.should be_kind_of(DataMapper::Resource)
+        end
+
+        it 'should return the expected Resource' do
+          @return.should == @expected
+        end
+      end
+    end
+
+    describe 'when the target model is scoped' do
+      before :all do
+        @resource = @model.new
+        @car.__send__("#{@name}=", @resource)
+        @car.save
+
+        # set the model scope to not match the expected resource
+        @model.default_scope.update(:id.not => @resource.id)
+
+        @return = @car.model.get(*@car.key).__send__(@name)
+      end
+
+      it 'should return nil' do
+        @return.should be_nil
+      end
+    end
+  end
+end
+
+share_examples_for 'it creates a one mutator' do
+  describe 'mutator' do
+    describe 'when setting a Resource' do
+      before :all do
+        @expected = @model.new
+
+        @return = @car.__send__("#{@name}=", @expected)
+      end
+
+      it 'should return the expected Resource' do
+        @return.should equal(@expected)
+      end
+
+      it 'should set the Resource' do
+        @car.__send__(@name).should equal(@expected)
+      end
+
+      it 'should relate associated Resource' do
+        relationship       = Car.relationships[@name]
+        many_to_one        = relationship.kind_of?(DataMapper::Associations::ManyToOne::Relationship)
+        one_to_one_through = relationship.kind_of?(DataMapper::Associations::OneToOne::Relationship) && relationship.respond_to?(:through)
+
+        pending_if many_to_one || one_to_one_through do
+          @expected.car.should == @car
+        end
+      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.should be_saved
+        @expected.model.get(*@expected.key).car.should == @car
+      end
+    end
+
+    describe 'when setting a Hash' do
+      before :all do
+        @car.__send__("#{@name}=", @model.new)
+
+        attributes = { :id => 10 }
+        @expected  = @model.new(attributes)
+
+        @return = @car.__send__("#{@name}=", attributes)
+      end
+
+      it 'should return the expected Resource' do
+        @return.should == @expected
+      end
+
+      it 'should set the Resource' do
+        @car.__send__(@name).should equal(@return)
+      end
+
+      it 'should relate associated Resource' do
+        relationship       = Car.relationships[@name]
+        many_to_one        = relationship.kind_of?(DataMapper::Associations::ManyToOne::Relationship)
+        one_to_one_through = relationship.kind_of?(DataMapper::Associations::OneToOne::Relationship) && relationship.respond_to?(:through)
+
+        pending_if many_to_one || one_to_one_through do
+          @return.car.should == @car
+        end
+      end
+
+      it 'should persist the Resource' do
+        @car.save.should be(true)
+        @car.model.get(*@car.key).__send__(@name).should == @return
+      end
+
+      it 'should persist the associated Resource' do
+        @car.save.should be(true)
+        @return.should be_saved
+        @return.model.get(*@return.key).car.should == @car
+      end
+    end
+
+    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
+
+    describe 'when changing the Resource' 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 equal(@expected)
+      end
+
+      it 'should set the Resource' do
+        @car.__send__(@name).should equal(@expected)
+      end
+
+      it 'should relate associated Resource' do
+        relationship       = Car.relationships[@name]
+        many_to_one        = relationship.kind_of?(DataMapper::Associations::ManyToOne::Relationship)
+        one_to_one_through = relationship.kind_of?(DataMapper::Associations::OneToOne::Relationship) && relationship.respond_to?(:through)
+
+        pending_if 'should create back-reference', many_to_one || one_to_one_through do
+          @expected.car.should == @car
+        end
+      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.should be_saved
+        @expected.model.get(*@expected.key).car.should == @car
+      end
+    end
+  end
+end
+
+share_examples_for 'it creates a many accessor' do
+  describe 'accessor' do
+    describe 'when there is no child resource 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::Collection)
+      end
+
+      it 'should return an empty Collection' do
+        @return.should be_empty
+      end
+    end
+
+    describe 'when there is no child resource 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::Collection)
+      end
+
+      it 'should return an empty Collection' do
+        @return.should be_empty
+      end
+    end
+
+    describe 'when there is a child resource' do
+      before :all do
+        @return = nil
+
+        @expected = @model.new
+        @car.__send__("#{@name}=", [ @expected ])
+
+        @return = @car.__send__(@name)
+      end
+
+      it 'should return a Collection' do
+        @return.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should return expected Resources' do
+        @return.should == [ @expected ]
+      end
+    end
+
+    describe 'when the target model is scoped' do
+      before :all do
+        2.times { @car.__send__(@name).new }
+        @car.save
+
+        @expected = @car.__send__(@name).first
+        @expected.should_not be_nil
+
+        # set the model scope to only return the first record
+        @model.default_scope.update(
+          Hash[ @model.key(@repository.name).zip(@expected.key) ]
+        )
+
+        @return = @car.model.get(*@car.key).__send__(@name)
+      end
+
+      it 'should return a Collection' do
+        @return.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should return expected Resources' do
+        @return.should == [ @expected ]
+      end
+    end
+  end
+end
+
+share_examples_for 'it creates a many mutator' do
+  describe 'mutator' do
+    describe 'when setting an Array of Resources' 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) { |value, expected| value.should equal(expected) }
+      end
+
+      it 'should relate the associated Collection' do
+        pending_if Car.relationships[@name].kind_of?(DataMapper::Associations::ManyToMany::Relationship) do
+          @expected.each { |resource| resource.car.should == @car }
+        end
+      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 Resource' do
+        @car.save.should be(true)
+        @expected.each { |resource| resource.should be_saved }
+        @expected.each { |resource| resource.model.get(*resource.key).car.should == @car }
+      end
+    end
+
+    describe 'when setting an Array of Hashes' do
+      before :all do
+        attributes = { :id => 11 }
+        @hashes    = [ attributes             ]
+        @expected  = [ @model.new(attributes) ]
+
+        @return = @car.__send__("#{@name}=", @hashes)
+      end
+
+      it 'should return the expected Collection' do
+        @return.should == @expected
+      end
+
+      it 'should set the Collection' do
+        @car.__send__(@name).should == @return
+      end
+
+      it 'should relate the associated Collection' do
+        pending_if Car.relationships[@name].kind_of?(DataMapper::Associations::ManyToMany::Relationship) do
+          @return.each { |resource| resource.car.should == @car }
+        end
+      end
+
+      it 'should persist the Collection' do
+        @car.save.should be(true)
+        @car.model.get(*@car.key).__send__(@name).should == @return
+      end
+
+      it 'should persist the associated Resource' do
+        @car.save.should be(true)
+        @return.each { |resource| resource.should be_saved }
+        @return.each { |resource| resource.model.get(*resource.key).car.should == @car }
+      end
+    end
+
+    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::Collection)
+      end
+
+      it 'should set an 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
+
+    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
+        @car.__send__(@name).zip(@expected) { |value, expected| value.should equal(expected) }
+      end
+
+      it 'should relate associated Resource' do
+        pending_if Car.relationships[@name].kind_of?(DataMapper::Associations::ManyToMany::Relationship) do
+          @expected.each { |resource| resource.car.should == @car }
+        end
+      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 }
+        @expected.each { |resource| resource.model.get(*resource.key).car.should == @car }
+      end
+    end
+  end
+end
+
+describe DataMapper::Associations do
+  before :all do
+    class ::Car
+      include DataMapper::Resource
+
+      property :id,   Serial
+      property :name, String
+    end
+
+    class ::Engine
+      include DataMapper::Resource
+
+      property :id, Serial
+    end
+
+    class ::Door
+      include DataMapper::Resource
+
+      property :id, Serial
+    end
+
+    class ::Window
+      include DataMapper::Resource
+
+      property :id, Serial
+    end
+  end
+
+  def n
+    1.0/0
+  end
+
+  it { Engine.should respond_to(:belongs_to) }
+
+  describe '#belongs_to' do
+    before :all do
+      @model = Engine
+      @name  = :engine
+
+      Car.belongs_to(@name, :required => false)
+      Engine.has(1, :car)
+      DataMapper.finalize
+    end
+
+    supported_by :all do
+      before :all do
+        @car = Car.new
+      end
+
+      it { @car.should respond_to(@name) }
+
+      it_should_behave_like 'it creates a one accessor'
+
+      it { @car.should respond_to("#{@name}=") }
+
+      it_should_behave_like 'it creates a one mutator'
+
+      describe 'with a :key option' do
+        before :all do
+          @relationship = Car.belongs_to("#{@name}_with_key".to_sym, @model, :required => false, :key => true)
+          DataMapper.finalize
+        end
+
+        it 'should create a foreign key that is part of the key' do
+          @relationship.child_key.each do |property|
+            property.should be_key
+          end
+        end
+      end
+
+      describe 'with a :unique option' do
+        let(:unique) { [ :one, :two, :three ] }
+
+        before :all do
+          @relationship = Car.belongs_to("#{@name}_with_unique".to_sym, @model, :unique => unique)
+          DataMapper.finalize
+        end
+
+        it 'should create a foreign key that is unique' do
+          @relationship.child_key.each do |property|
+            property.should be_unique
+          end
+        end
+
+        it 'should create a foreign key that has a unique index' do
+          @relationship.child_key.each do |property|
+            property.unique_index.should equal(unique)
+          end
+        end
+      end
+    end
+
+    # TODO: refactor these specs into above structure once they pass
+    describe 'pending query specs' do
+      before :all do
+        Car.has(1, :engine)
+        Engine.belongs_to(:car)
+        DataMapper.finalize
+      end
+
+      supported_by :all do
+        describe 'querying for a parent resource when only the foreign key is set' do
+          before :all do
+            # create a car that would be returned if the query is not
+            # scoped properly to retrieve @car
+            Car.create
+
+            @car = Car.create
+            engine = Engine.new(:car_id => @car.id)
+
+            @return = engine.car
+          end
+
+          it 'should return a Resource' do
+            @return.should be_kind_of(DataMapper::Resource)
+          end
+
+          it 'should return expected Resource' do
+            @return.should eql(@car)
+          end
+        end
+
+        describe 'querying for a parent resource' do
+          before :all do
+            @car = Car.create
+            @engine = Engine.create(:car => @car)
+            @resource = @engine.car(:id => @car.id)
+          end
+
+          it 'should return a Resource' do
+            @resource.should be_kind_of(DataMapper::Resource)
+          end
+
+          it 'should return expected Resource' do
+            @resource.should eql(@car)
+          end
+        end
+
+        describe 'querying for a parent resource that does not exist' do
+          before :all do
+            @car = Car.create
+            @engine = Engine.create(:car => @car)
+            @resource = @engine.car(:id.not => @car.id)
+          end
+
+          it 'should return nil' do
+            @resource.should be_nil
+          end
+        end
+
+        describe 'changing the parent resource' do
+          before :all do
+            @car = Car.create
+            @engine = Engine.new
+            @engine.car = @car
+          end
+
+          it 'should set the associated foreign key' do
+            @engine.car_id.should == @car.id
+          end
+
+          it 'should add the engine object to the car' do
+            pending 'Changing a belongs_to parent should add the object to the correct association' do
+              @car.engines.should be_include(@engine)
+            end
+          end
+        end
+
+        describe 'changing the parent foreign key' do
+          before :all do
+            @car = Car.create
+
+            @engine = Engine.new(:car_id => @car.id)
+          end
+
+          it 'should set the associated resource' do
+            @engine.car.should eql(@car)
+          end
+        end
+
+        describe 'changing an existing resource through the relation' do
+          before :all do
+            @car1 = Car.create
+            @car2 = Car.create
+            @engine = Engine.create(:car => @car1)
+            @engine.car = @car2
+          end
+
+          it 'should also change the foreign key' do
+            @engine.car_id.should == @car2.id
+          end
+
+          it 'should add the engine to the car' do
+            pending 'Changing a belongs_to parent should add the object to the correct association' do
+              @car2.engines.should be_include(@engine)
+            end
+          end
+        end
+
+        describe 'changing an existing resource through the relation' do
+          before :all do
+            @car1 = Car.create
+            @car2 = Car.create
+            @engine = Engine.create(:car => @car1)
+            @engine.car_id = @car2.id
+          end
+
+          it 'should also change the foreign key' do
+            @engine.car.should eql(@car2)
+          end
+
+          it 'should add the engine to the car' do
+            pending 'a change to the foreign key should also change the related object' do
+              @car2.engines.should be_include(@engine)
+            end
+          end
+        end
+      end
+    end
+
+    describe 'with a model' do
+      before :all do
+        Engine.belongs_to(:vehicle, Car)
+        DataMapper.finalize
+      end
+
+      it 'should set the relationship target model' do
+        Engine.relationships[:vehicle].target_model.should == Car
+      end
+    end
+
+    describe 'with a :model option' do
+      before :all do
+        Engine.belongs_to(:vehicle, :model => Car)
+        DataMapper.finalize
+      end
+
+      it 'should set the relationship target model' do
+        Engine.relationships[:vehicle].target_model.should == Car
+      end
+    end
+
+    describe 'with a single element as :child_key option' do
+      before :all do
+        Engine.belongs_to(:vehicle, :model => Car, :child_key => :bike_id)
+        DataMapper.finalize
+      end
+
+      it 'should set the relationship child key' do
+        Engine.relationships[:vehicle].child_key.map { |property| property.name }.should == [:bike_id]
+      end
+    end
+
+    describe 'with an array as :child_key option' do
+      before :all do
+        Engine.belongs_to(:vehicle, :model => Car, :child_key => [:bike_id])
+        DataMapper.finalize
+      end
+
+      it 'should set the relationship child key' do
+        Engine.relationships[:vehicle].child_key.map { |property| property.name }.should == [:bike_id]
+      end
+    end
+
+    describe 'with a single element as :parent_key option' do
+      before :all do
+        Engine.belongs_to(:vehicle, :model => Car, :parent_key => :name)
+        DataMapper.finalize
+      end
+
+      it 'should set the relationship parent key' do
+        Engine.relationships[:vehicle].parent_key.map { |property| property.name }.should == [:name]
+      end
+    end
+
+    describe 'with an array as :parent_key option' do
+      before :all do
+        Engine.belongs_to(:vehicle, :model => Car, :parent_key => [:name])
+        DataMapper.finalize
+      end
+
+      it 'should set the relationship parent key' do
+        Engine.relationships[:vehicle].parent_key.map { |property| property.name }.should == [:name]
+      end
+    end
+  end
+
+  it { Car.should respond_to(:has) }
+
+  describe '#has' do
+    describe '1' do
+      before :all do
+        @model = Engine
+        @name  = :engine
+
+        Car.has(1, @name)
+        Engine.belongs_to(:car)
+        DataMapper.finalize
+      end
+
+      supported_by :all do
+        before :all do
+          @car = Car.new
+        end
+
+        it { @car.should respond_to(@name) }
+
+        it_should_behave_like 'it creates a one accessor'
+
+        it { @car.should respond_to("#{@name}=") }
+
+        it_should_behave_like 'it creates a one mutator'
+      end
+    end
+
+    describe '1 through' do
+      before :all do
+        @model = Engine
+        @name  = :engine
+
+        Car.has(1, @name, :through => DataMapper::Resource)
+        Engine.has(1, :car, :through => DataMapper::Resource)
+        DataMapper.finalize
+      end
+
+      supported_by :all do
+        before :all do
+          @no_join = defined?(DataMapper::Adapters::InMemoryAdapter) && @adapter.kind_of?(DataMapper::Adapters::InMemoryAdapter) ||
+                     defined?(DataMapper::Adapters::YamlAdapter)     && @adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+        end
+
+        before :all do
+          @car = Car.new
+        end
+
+        before do
+          pending if @no_join
+        end
+
+        it { @car.should respond_to(@name) }
+
+        it_should_behave_like 'it creates a one accessor'
+
+        it { @car.should respond_to("#{@name}=") }
+
+        it_should_behave_like 'it creates a one mutator'
+      end
+    end
+
+    describe 'n..n' do
+      before :all do
+        @model = Door
+        @name  = :doors
+
+        Car.has(1..4, @name)
+        Door.belongs_to(:car, :required => false)
+        DataMapper.finalize
+      end
+
+      supported_by :all do
+        before :all do
+          @car = Car.new
+        end
+
+        it { @car.should respond_to(@name) }
+
+        it_should_behave_like 'it creates a many accessor'
+
+        it { @car.should respond_to("#{@name}=") }
+
+        it_should_behave_like 'it creates a many mutator'
+      end
+    end
+
+    describe 'n..n through' do
+      before :all do
+        @model = Window
+        @name  = :windows
+
+        Window.has(1, :car, :through => DataMapper::Resource)
+        Car.has(1..4, :windows, :through => DataMapper::Resource)
+        DataMapper.finalize
+      end
+
+      supported_by :all do
+        before :all do
+          @no_join = defined?(DataMapper::Adapters::InMemoryAdapter) && @adapter.kind_of?(DataMapper::Adapters::InMemoryAdapter) ||
+                     defined?(DataMapper::Adapters::YamlAdapter)     && @adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+        end
+
+        before :all do
+          @car = Car.new
+        end
+
+        before do
+          pending if @no_join
+        end
+
+        it { @car.should respond_to(@name) }
+
+        it_should_behave_like 'it creates a many accessor'
+
+        it { @car.should respond_to("#{@name}=") }
+
+        it_should_behave_like 'it creates a many mutator'
+      end
+    end
+
+    describe 'when the 3rd argument is a Model' do
+      before :all do
+        Car.has(1, :engine, Engine)
+        DataMapper.finalize
+      end
+
+      it 'should set the relationship target model' do
+        Car.relationships[:engine].target_model.should == Engine
+      end
+    end
+
+    describe 'when the 3rd argument is a String' do
+      before :all do
+        Car.has(1, :engine, 'Engine')
+        DataMapper.finalize
+      end
+
+      it 'should set the relationship target model' do
+        Car.relationships[:engine].target_model.should == Engine
+      end
+    end
+
+    it 'should raise an exception if the cardinality is not understood' do
+      lambda { Car.has(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.has(2..1, :doors) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe 'property prefix inference' do
+    describe 'when a relationship has an inverse' do
+      before :all do
+        @engine_relationship = Car.has(1, :engine, :inverse => Engine.belongs_to(:sports_car, Car))
+        DataMapper.finalize
+      end
+
+      supported_by :all do
+        it 'should have a child key prefix the same as the inverse relationship' do
+          @engine_relationship.child_key.map { |property| property.name }.should == [ :sports_car_id ]
+        end
+      end
+    end
+
+    describe 'when a relationship does not have an inverse' do
+      before :all do
+        @engine_relationship = Car.has(1, :engine)
+        DataMapper.finalize
+      end
+
+      supported_by :all do
+        it 'should have a child key prefix inferred from the source model name' do
+          @engine_relationship.child_key.map { |property| property.name }.should == [ :car_id ]
+        end
+      end
+    end
+
+    describe 'when a relationship is inherited' do
+      describe 'has an inverse' do
+        before :all do
+          Car.property(:type, DataMapper::Property::Discriminator)
+
+          class ::ElectricCar < Car; end
+
+          Car.has(1, :engine, :inverse => Engine.belongs_to(:sports_car, Car))
+          DataMapper.finalize
+        end
+
+        supported_by :all do
+          before :all do
+            @engine_relationship = ElectricCar.relationships(@repository.name)[:engine]
+          end
+
+          it 'should have a source model equal to the ancestor' do
+            @engine_relationship.source_model.should equal(Car)
+          end
+
+          it 'should have a child key prefix the same as the inverse relationship' do
+            @engine_relationship.child_key.map { |property| property.name }.should == [ :sports_car_id ]
+          end
+        end
+      end
+
+      describe 'does not have an inverse' do
+        before :all do
+          Car.property(:type, DataMapper::Property::Discriminator)
+
+          class ::ElectricCar < Car; end
+
+          Car.has(1, :engine)
+          DataMapper.finalize
+        end
+
+        supported_by :all do
+          before :all do
+            @engine_relationship = ElectricCar.relationships(@repository.name)[:engine]
+          end
+
+          it 'should have a source model equal to the ancestor' do
+            @engine_relationship.source_model.should equal(Car)
+          end
+
+          it 'should have a child key prefix inferred from the source model name' do
+            @engine_relationship.child_key.map { |property| property.name }.should == [ :car_id ]
+          end
+        end
+      end
+    end
+
+    describe "when a subclass defines it's own relationship" do
+      describe 'has an inverse' do
+        before :all do
+          Car.property(:type, DataMapper::Property::Discriminator)
+
+          class ::ElectricCar < Car; end
+
+          ElectricCar.has(1, :engine, :inverse => Engine.belongs_to(:sports_car, Car))
+          DataMapper.finalize
+        end
+
+        supported_by :all do
+          before :all do
+            @engine_relationship = ElectricCar.relationships(@repository.name)[:engine]
+          end
+
+          it 'should have a source model equal to the descendant' do
+            @engine_relationship.source_model.should equal(ElectricCar)
+          end
+
+          it 'should have a child key prefix the same as the inverse relationship' do
+            @engine_relationship.child_key.map { |property| property.name }.should == [ :sports_car_id ]
+          end
+        end
+      end
+
+      describe 'does not have an inverse' do
+        before :all do
+          Car.property(:type, DataMapper::Property::Discriminator)
+
+          class ::ElectricCar < Car; end
+
+          ElectricCar.has(1, :engine)
+          DataMapper.finalize
+        end
+
+        supported_by :all do
+          before :all do
+            @engine_relationship = ElectricCar.relationships(@repository.name)[:engine]
+          end
+
+          it 'should have a source model equal to the descendant' do
+            @engine_relationship.source_model.should equal(ElectricCar)
+          end
+
+          it 'should have a child key prefix inferred from the source model name' do
+            @engine_relationship.child_key.map { |property| property.name }.should == [ :electric_car_id ]
+          end
+        end
+      end
+    end
+  end
+
+  describe 'child is also a parent' do
+    before :all do
+      class ::Employee
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :name, String
+
+        belongs_to :company
+      end
+
+      class ::Company
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :name, String
+
+        belongs_to :owner, Employee, :required => false
+        has n, :employees
+      end
+      DataMapper.finalize
+    end
+
+    supported_by :all do
+      before :all do
+        @company  = Company.create(:name => 'ACME Inc.')
+        @employee = @company.employees.create(:name => 'Wil E. Coyote')
+      end
+
+      it 'should save the child as a parent' do
+        lambda {
+          @company.owner = @employee
+          @company.save.should be(true)
+        }.should_not raise_error
+      end
+    end
+  end
+end