datamapper-dm-core 0.9.11 → 0.10.0

data/spec/unit/associations/one_to_many_spec.rb

@@ -1,393 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe DataMapper::Associations::OneToMany do
-
-  load_models_for_metaphor :vehicles
-
-  before do
-    @class = Class.new do
-      def self.name
-        'User'
-      end
-
-      include DataMapper::Resource
-
-      property :user_id, Integer, :key => true
-    end
-  end
-
-  it 'should provide #has' do
-    @class.should respond_to(:has)
-  end
-
-  describe '#has' do
-    it 'should return a Relationship' do
-      @class.has(@class.n, :orders).should be_kind_of(DataMapper::Associations::Relationship)
-    end
-
-    describe 'relationship' do
-      before do
-        @relationship = mock('relationship')
-        DataMapper::Associations::Relationship.stub!(:new).and_return(@relationship)
-      end
-
-      it 'should receive the name' do
-        DataMapper::Associations::Relationship.should_receive(:new) do |name,_,_,_,_|
-          name.should == :orders
-        end
-        @class.has(@class.n, :orders)
-      end
-
-      it 'should receive the repository name' do
-        DataMapper::Associations::Relationship.should_receive(:new) do |_,repository_name,_,_,_|
-          repository_name.should == :mock
-        end
-        repository(:mock) do
-          @class.has(@class.n, :orders)
-        end
-      end
-
-      it 'should receive the child model name when passed in as class_name' do
-        DataMapper::Associations::Relationship.should_receive(:new) do |_,_,child_model_name,_,_|
-          child_model_name.should == 'Company::Order'
-        end
-        @class.has(@class.n, :orders, :class_name => 'Company::Order')
-      end
-
-      it 'should receive the child model name when class_name not passed in' do
-        DataMapper::Associations::Relationship.should_receive(:new) do |_,_,child_model_name,_,_|
-          child_model_name.should == 'Order'
-        end
-        @class.has(@class.n, :orders)
-      end
-
-      it 'should receive the parent model name' do
-        DataMapper::Associations::Relationship.should_receive(:new) do |_,_,_,parent_model_name,_|
-          parent_model_name.should == @class
-        end
-        @class.has(@class.n, :orders)
-      end
-
-      it 'should receive the parent model name' do
-        options = { :min => 0, :max => 100 }
-        DataMapper::Associations::Relationship.should_receive(:new) do |_,_,_,parent_model_name,_|
-          options.object_id.should == options.object_id
-        end
-        @class.has(@class.n, :orders, options)
-      end
-    end
-
-    it 'should add an accessor for the proxy' do
-      @class.new.should_not respond_to(:orders)
-      @class.has(@class.n, :orders)
-      @class.new.should respond_to(:orders)
-    end
-
-    describe 'proxy accessor' do
-      before :all do
-        class ::User
-          include DataMapper::Resource
-        end
-
-        class ::Order
-          include DataMapper::Resource
-        end
-      end
-
-      it 'should return a OneToMany::Proxy' do
-        @class.has(@class.n, :orders)
-        @class.new.orders.should be_kind_of(DataMapper::Associations::OneToMany::Proxy)
-      end
-    end
-  end
-
-  it 'should work with classes inside modules'
-end
-
-describe DataMapper::Associations::OneToMany::Proxy do
-  before do
-    @parent       = mock('parent', :new_record? => true, :kind_of? => true)
-    @resource     = mock('resource', :null_object => true)
-    @collection   = []
-    @parent_key   = mock('parent key', :get => [])
-    @repository   = mock('repository', :save => nil, :kind_of? => true)
-    @relationship = mock('relationship', :get_children => @collection, :query => {}, :kind_of? => true, :child_key => [], :parent_key => @parent_key)
-    @association  = DataMapper::Associations::OneToMany::Proxy.new(@relationship, @parent)
-  end
-
-  describe 'a method that relates the resource', :shared => true do
-    it 'should add the resource to the collection' do
-      @association.should_not include(@resource)
-      do_add.should == return_value
-      @association.should include(@resource)
-    end
-
-    it 'should not automatically save that the resource was added to the association' do
-      @relationship.should_not_receive(:attach_parent)
-      do_add.should == return_value
-    end
-
-    it 'should persist the addition after saving the association' do
-      @relationship.should_receive(:with_repository).with(@resource).and_yield(@repository)
-      do_add.should == return_value
-      @relationship.should_receive(:attach_parent).with(@resource, @parent)
-      @association.save
-    end
-  end
-
-  describe 'a method that orphans the resource', :shared => true do
-    before do
-      @association << @resource
-    end
-
-    it 'should remove the resource from the collection' do
-      @association.should include(@resource)
-      do_remove.should == return_value
-      @association.should_not include(@resource)
-    end
-
-    it 'should not automatically save that the resource was removed from the association' do
-      @relationship.should_not_receive(:attach_parent)
-      do_remove.should == return_value
-    end
-
-    it 'should persist the removal after saving the association' do
-      @relationship.should_receive(:with_repository).with(@resource).and_yield(@repository)
-      do_remove.should == return_value
-      @relationship.should_receive(:attach_parent).with(@resource, nil)
-      @association.save
-    end
-  end
-
-  it 'should provide #<<' do
-    @association.should respond_to(:<<)
-  end
-
-  describe '#<<' do
-    def do_add
-      @association << @resource
-    end
-
-    def return_value
-      @association
-    end
-
-    it_should_behave_like 'a method that relates the resource'
-  end
-
-  it 'should provide #push' do
-    @association.should respond_to(:push)
-  end
-
-  describe '#push' do
-    def do_add
-      @association.push(@resource)
-    end
-
-    def return_value
-      @association
-    end
-
-    it_should_behave_like 'a method that relates the resource'
-  end
-
-  it 'should provide #unshift' do
-    @association.should respond_to(:unshift)
-  end
-
-  describe '#unshift' do
-    def do_add
-      @association.unshift(@resource)
-    end
-
-    def return_value
-      @association
-    end
-
-    it_should_behave_like 'a method that relates the resource'
-  end
-
-  it 'should provide #replace' do
-    @association.should respond_to(:replace)
-  end
-
-  describe '#replace' do
-    before do
-      @children = [
-        mock('child 1', :save => true),
-        mock('child 2', :save => true),
-      ]
-      @collection << @resource
-      @collection.stub!(:loaded?).and_return(true)
-      @relationship.stub!(:attach_parent)
-    end
-
-    def do_replace
-      @association.replace(@children)
-    end
-
-    def return_value
-      @association
-    end
-
-    it 'should remove the resource from the collection' do
-      @association.should include(@resource)
-      do_replace.should == return_value
-      @association.should_not include(@resource)
-    end
-
-    it 'should not automatically save that the resource was removed from the association' do
-      @relationship.should_not_receive(:attach_parent)
-      do_replace.should == return_value
-    end
-
-    it 'should persist the removal after saving the association' do
-      do_replace.should == return_value
-      @relationship.should_receive(:with_repository).exactly(3).times.and_yield(@repository)
-      @relationship.should_receive(:attach_parent).with(@resource, nil)
-      @association.save
-    end
-
-    it 'should not automatically save that the children were added to the association' do
-      @relationship.should_not_receive(:attach_parent)
-      do_replace.should == return_value
-    end
-
-    it 'should persist the addition after saving the association' do
-      do_replace.should == return_value
-      @relationship.should_receive(:with_repository).exactly(3).times.and_yield(@repository)
-      @relationship.should_receive(:attach_parent).with(@children[0], @parent)
-      @relationship.should_receive(:attach_parent).with(@children[1], @parent)
-      @association.save
-    end
-  end
-
-  it 'should provide #pop' do
-    @association.should respond_to(:pop)
-  end
-
-  describe '#pop' do
-    def do_remove
-      @association.pop
-    end
-
-    def return_value
-      @resource
-    end
-
-    it_should_behave_like 'a method that orphans the resource'
-  end
-
-  it 'should provide #shift' do
-    @association.should respond_to(:shift)
-  end
-
-  describe '#shift' do
-    def do_remove
-      @association.shift
-    end
-
-    def return_value
-      @resource
-    end
-
-    it_should_behave_like 'a method that orphans the resource'
-  end
-
-  it 'should provide #delete' do
-    @association.should respond_to(:delete)
-  end
-
-  describe '#delete' do
-    def do_remove
-      @association.delete(@resource)
-    end
-
-    def return_value
-      @resource
-    end
-
-    it_should_behave_like 'a method that orphans the resource'
-  end
-
-  it 'should provide #delete_at' do
-    @association.should respond_to(:delete_at)
-  end
-
-  describe '#delete_at' do
-    def do_remove
-      @association.delete_at(0)
-    end
-
-    def return_value
-      @resource
-    end
-
-    it_should_behave_like 'a method that orphans the resource'
-  end
-
-  it 'should provide #clear' do
-    @association.should respond_to(:clear)
-  end
-
-  describe '#clear' do
-    def do_remove
-      @association.clear
-    end
-
-    def return_value
-      @association
-    end
-
-    it_should_behave_like 'a method that orphans the resource'
-
-    it 'should empty the collection' do
-      @association << mock('other resource', :new_record? => false)
-      @association.should have(2).entries
-      do_remove
-      @association.should be_empty
-    end
-  end
-
-  it 'should provide #reload' do
-    @association.should respond_to(:reload)
-  end
-
-  describe '#reload' do
-    before do
-      @children = [ mock('child 1', :save => true), mock('child 2', :save => true) ]
-      @relationship.stub!(:get_children).and_return(@children)
-    end
-
-    it 'should set the @children ivar to nil' do
-      @association.__send__(:children).should == @children # Sanity check.
-
-      # We can't test the value of the @children instance variable since
-      # #instance_variable_get will be run on @children (thanks to
-      # Proxy#method_missing). Instead, test that Relationship#get_children is
-      # run -- if @children wasn't set to nil, this expectation should fail.
-      @relationship.should_receive(:get_children).once.and_return(@children)
-      @association.reload
-
-      # Trigger #get_children on the relationship.
-      @association.__send__(:children).should == @children
-    end
-
-    it 'should return self' do
-      @association.reload.should be_kind_of(DataMapper::Associations::OneToMany::Proxy)
-      @association.reload.object_id.should == @association.object_id
-    end
-  end
-
-  describe 'when deleting the parent' do
-    it 'should delete all the children without calling destroy if relationship :dependent is :delete_all'
-
-    it 'should destroy all the children if relationship :dependent is :destroy'
-
-    it 'should set the parent key for each child to nil if relationship :dependent is :nullify'
-
-    it 'should restrict the parent from being deleted if a child remains if relationship :dependent is restrict'
-
-    it 'should be restrict by default if relationship :dependent is not specified'
-  end
-end

data/spec/unit/associations/one_to_one_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe "DataMapper::Associations::OneToOne" do
-
-  it "should allow a declaration" do
-  end
-end

data/spec/unit/associations/relationship_spec.rb

@@ -1,71 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe DataMapper::Associations::Relationship do
-
-  load_models_for_metaphor :vehicles
-
-  it "should describe an association" do
-    belongs_to = DataMapper::Associations::Relationship.new(
-      :manufacturer,
-      :mock,
-      Vehicle,
-      Manufacturer,
-      { :child_key => [ :manufacturer_id ] }
-    )
-
-    belongs_to.should respond_to(:name)
-    belongs_to.should respond_to(:with_repository)
-    belongs_to.should respond_to(:child_key)
-    belongs_to.should respond_to(:parent_key)
-  end
-
-  it "should map properties explicitly when an association method passes them in its options" do
-    belongs_to = DataMapper::Associations::Relationship.new(
-      :manufacturer,
-      :mock,
-      Vehicle,
-      Manufacturer,
-      { :child_key => [ :manufacturer_id ], :parent_key => [ :id ] }
-    )
-
-    belongs_to.name.should == :manufacturer
-    belongs_to.with_repository do |r|
-      r.name.should == :mock
-    end
-
-    belongs_to.child_key.should be_a_kind_of(DataMapper::PropertySet)
-    belongs_to.parent_key.should be_a_kind_of(DataMapper::PropertySet)
-
-    belongs_to.child_key.to_a.should == Vehicle.properties(:mock).slice(:manufacturer_id)
-    belongs_to.parent_key.to_a.should == Manufacturer.properties(:mock).key
-  end
-
-  it "should infer properties when options aren't passed" do
-    has_many = DataMapper::Associations::Relationship.new(
-      :models,
-      :mock,
-      Vehicle,
-      Manufacturer,
-      { :child_key => [:model_id] }
-    )
-
-    has_many.name.should == :models
-    has_many.with_repository do |r|
-      r.name.should == :mock
-    end
-
-    has_many.child_key.should be_a_kind_of(DataMapper::PropertySet)
-    has_many.parent_key.should be_a_kind_of(DataMapper::PropertySet)
-    # Vehicle.has n, :models, :class_name => 'Manufacturer', :child_key => "models_id"
-    has_many.child_key.to_a.should == Vehicle.properties(:mock).slice(:model_id)
-    has_many.parent_key.to_a.should == Manufacturer.properties(:mock).key
-  end
-
-  it "should generate child properties with a safe subset of the parent options" do
-    pending
-    # For example, :size would be an option you'd want a generated child Property to copy,
-    # but :serial or :key obviously not. So need to take a good look at Property::OPTIONS to
-    # see what applies and what doesn't.
-  end
-
-end

data/spec/unit/associations_spec.rb

@@ -1,242 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe "DataMapper::Associations" do
-
-  load_models_for_metaphor :vehicles
-
-  before do
-    @relationship = mock(DataMapper::Associations::Relationship)
-    @n = 1.0/0
-
-    Manufacturer.mock_relationship = Vehicle.mock_relationship = @relationship
-  end
-
-  describe "#many_to_one_relationships" do
-    before :all do
-      module ::MTORelationships
-        class A
-          include DataMapper::Resource
-          def self.default_repository_name
-            :a_db
-          end
-          repository(:b_db) do
-            belongs_to :b
-          end
-          repository(:c_db) do
-            belongs_to :c
-          end
-        end
-        class B
-          include DataMapper::Resource
-          def self.default_repository_name
-            :b_db
-          end
-        end
-        class C
-          include DataMapper::Resource
-          def self.default_repository_name
-            :c_db
-          end
-        end
-      end
-    end
-    it "should list all relationships that are one-to-many" do
-      MTORelationships::A.many_to_one_relationships.sort_by { |r| r.name.to_s }.should == [MTORelationships::A.relationships(:b_db)[:b], MTORelationships::A.relationships(:c_db)[:c]]
-    end
-  end
-
-  describe ".relationships" do
-    class ::B
-      include DataMapper::Resource
-    end
-
-    class ::C
-      include DataMapper::Resource
-
-      repository(:mock) do
-        has 1, :b
-      end
-    end
-
-    class ::D
-      include DataMapper::Resource
-      has 1, :b
-    end
-
-    class ::E < D
-    end
-
-    class ::F < D
-      has 1, :a
-    end
-
-    it "should assume the default repository when no arguments are passed" do
-      lambda do
-        C.relationships
-      end.should_not raise_error
-    end
-
-    it "should return the right set of relationships given the repository name" do
-      C.relationships.should be_empty
-      C.relationships(:mock).should_not be_empty
-    end
-
-    it "should return the right set of relationships given the inheritance" do
-      E.relationships.should have(1).entries
-      D.relationships.should have(1).entries
-      F.relationships.should have(2).entries
-    end
-  end
-
-  describe ".has" do
-
-    it "should allow a declaration" do
-      lambda do
-        class ::Manufacturer
-          has 1, :halo_car
-        end
-      end.should_not raise_error
-    end
-
-    it "should not allow a constraint that is not an Integer, Range or Infinity" do
-      lambda do
-        class ::Manufacturer
-          has '1', :halo_car
-        end
-      end.should raise_error(ArgumentError)
-    end
-
-    it "should not allow a constraint where the min is larger than the max" do
-      lambda do
-        class ::Manufacturer
-          has 1..0, :halo_car
-        end
-      end.should raise_error(ArgumentError)
-    end
-
-    it "should not allow overwriting of the auto assigned min/max values with keys" do
-      DataMapper::Associations::OneToMany.should_receive(:setup).
-        with(:vehicles, Manufacturer, { :min => 1, :max => 2 }).
-        and_return(@relationship)
-
-      class ::Manufacturer
-        has(1..2, :vehicles, :min => 5, :max => 10).should == mock_relationship
-      end
-    end
-
-    describe "one-to-one syntax" do
-      it "should create a basic one-to-one association with fixed constraint" do
-        DataMapper::Associations::OneToOne.should_receive(:setup).
-          with(:halo_car, Manufacturer, { :min => 1, :max => 1 }).
-          and_return(@relationship)
-
-        class ::Manufacturer
-          has(1, :halo_car).should == mock_relationship
-        end
-      end
-
-      it "should create a basic one-to-one association with min/max constraints" do
-        DataMapper::Associations::OneToOne.should_receive(:setup).
-          with(:halo_car, Manufacturer, { :min => 0, :max => 1 }).
-          and_return(@relationship)
-
-        class ::Manufacturer
-          has(0..1, :halo_car).should == mock_relationship
-        end
-      end
-
-      it "should create a one-to-one association with options" do
-        DataMapper::Associations::OneToOne.should_receive(:setup).
-          with(:halo_car, Manufacturer, { :min => 1, :max => 1, :class_name => 'Car' }).
-          and_return(@relationship)
-
-        class ::Manufacturer
-          has(1, :halo_car, :class_name => 'Car').should == mock_relationship
-        end
-      end
-    end
-
-    describe "one-to-many syntax" do
-      it "should create a basic one-to-many association with no constraints" do
-        DataMapper::Associations::OneToMany.should_receive(:setup).
-          with(:vehicles, Manufacturer, { :min => 0, :max => @n }).
-          and_return(@relationship)
-
-        class ::Manufacturer
-          has(n, :vehicles).should == mock_relationship
-        end
-      end
-
-      it "should create a one-to-many association with fixed constraint" do
-        DataMapper::Associations::OneToMany.should_receive(:setup).
-          with(:vehicles, Manufacturer, { :min => 4, :max => 4 }).
-          and_return(@relationship)
-
-        class ::Manufacturer
-          has(4, :vehicles).should == mock_relationship
-        end
-      end
-
-      it "should create a one-to-many association with min/max constraints" do
-        DataMapper::Associations::OneToMany.should_receive(:setup).
-          with(:vehicles, Manufacturer, { :min => 2, :max => 4 }).
-          and_return(@relationship)
-
-        class ::Manufacturer
-          has(2..4, :vehicles).should == mock_relationship
-        end
-      end
-
-      it "should create a one-to-many association with options" do
-        DataMapper::Associations::OneToMany.should_receive(:setup).
-          with(:vehicles, Manufacturer, { :min => 1, :max => @n, :class_name => 'Car' }).
-          and_return(@relationship)
-
-        class ::Manufacturer
-          has(1..n, :vehicles, :class_name => 'Car').should == mock_relationship
-        end
-      end
-
-      # do not remove or change this spec.
-      it "should raise an exception when n..n is used for the cardinality" do
-        lambda do
-          class ::Manufacturer
-            has n..n, :subsidiaries, :class_name => 'Manufacturer'
-          end
-        end.should raise_error(ArgumentError)
-      end
-
-      it "should create one-to-many association and pass the :through option if specified" do
-        DataMapper::Associations::OneToMany.should_receive(:setup).
-          with(:suppliers, Vehicle, { :min => 0, :max => @n, :through => :manufacturers }).
-          and_return(@relationship)
-
-        class ::Vehicle
-          has(n, :suppliers, :through => :manufacturers).should == mock_relationship
-        end
-      end
-    end
-  end
-
-  describe ".belongs_to" do
-    it "should create a basic many-to-one association" do
-      DataMapper::Associations::ManyToOne.should_receive(:setup).
-        with(:vehicle, Manufacturer, {}).
-        and_return(@relationship)
-
-      class ::Manufacturer
-        belongs_to(:vehicle).should == mock_relationship
-      end
-    end
-
-    it "should create a many-to-one association with options" do
-      DataMapper::Associations::ManyToOne.should_receive(:setup).
-        with(:vehicle, Manufacturer, :class_name => 'Car', :child_key => [ :car_id ]).
-        and_return(@relationship)
-
-      class ::Manufacturer
-        belongs_to(:vehicle, :class_name => 'Car', :child_key => [ :car_id ]).should == mock_relationship
-      end
-    end
-  end
-end