dm-core 0.9.11 → 0.10.0

data/spec/unit/adapters/in_memory_adapter_spec.rb

@@ -1,98 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', "..", 'spec_helper'))
-
-describe DataMapper::Adapters::InMemoryAdapter do
-  before do
-    DataMapper.setup(:inmem, :adapter => 'in_memory')
-
-    class ::Heffalump
-      include DataMapper::Resource
-
-      def self.default_repository_name
-        :inmem
-      end
-
-      property :color,      String, :key => true # TODO: Drop the 'must have a key' limitation
-      property :num_spots,  Integer
-      property :striped,    Boolean
-    end
-
-    @heff1 = Heffalump.create(:color => 'Black', :num_spots => 0,   :striped => true)
-    @heff2 = Heffalump.create(:color => 'Brown', :num_spots => 25,  :striped => false)
-    @heff3 = Heffalump.create(:color => 'Blue',  :num_spots => nil, :striped => false)
-  end
-
-  it 'should successfully save an object' do
-    @heff1.new_record?.should be_false
-  end
-
-  it 'should be able to get the object' do
-    Heffalump.get('Black').should == @heff1
-  end
-
-  it 'should be able to get all the objects' do
-    Heffalump.all.should == [@heff1, @heff2, @heff3]
-  end
-
-  it 'should be able to search for objects with equal value' do
-    Heffalump.all(:striped => true).should == [@heff1]
-  end
-
-  it 'should be able to search for objects included in an array of values' do
-    Heffalump.all(:num_spots => [ 25, 50, 75, 100 ]).should == [@heff2]
-  end
-
-  it 'should be able to search for objects included in a range of values' do
-    Heffalump.all(:num_spots => 25..100).should == [@heff2]
-  end
-
-  it 'should be able to search for objects with nil value' do
-    Heffalump.all(:num_spots => nil).should == [@heff3]
-  end
-
-  it 'should be able to search for objects with not equal value' do
-    Heffalump.all(:striped.not => true).should == [@heff2, @heff3]
-  end
-
-  it 'should be able to search for objects not included in an array of values' do
-    Heffalump.all(:num_spots.not => [ 25, 50, 75, 100 ]).should == [@heff1, @heff3]
-  end
-
-  it 'should be able to search for objects not included in a range of values' do
-    Heffalump.all(:num_spots.not => 25..100).should == [@heff1, @heff3]
-  end
-
-  it 'should be able to search for objects with not nil value' do
-    Heffalump.all(:num_spots.not => nil).should == [@heff1, @heff2]
-  end
-
-  it 'should be able to search for objects that match value' do
-    Heffalump.all(:color.like => 'Bl').should == [@heff1, @heff3]
-  end
-
-  it 'should be able to search for objects with value greater than' do
-    Heffalump.all(:num_spots.gt => 0).should == [@heff2]
-  end
-
-  it 'should be able to search for objects with value greater than or equal to' do
-    Heffalump.all(:num_spots.gte => 0).should == [@heff1, @heff2]
-  end
-
-  it 'should be able to search for objects with value less than' do
-    Heffalump.all(:num_spots.lt => 1).should == [@heff1]
-  end
-
-  it 'should be able to search for objects with value less than or equal to' do
-    Heffalump.all(:num_spots.lte => 0).should == [@heff1]
-  end
-
-  it 'should be able to update an object' do
-    @heff1.num_spots = 10
-    @heff1.save
-    Heffalump.get('Black').num_spots.should == 10
-  end
-
-  it 'should be able to destroy an object' do
-    @heff1.destroy
-    Heffalump.all.size.should == 2
-  end
-end

data/spec/unit/adapters/postgres_adapter_spec.rb

@@ -1,133 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', "..", 'spec_helper'))
-
-if HAS_POSTGRES
-  describe DataMapper::Adapters::PostgresAdapter do
-    before :all do
-      @adapter = repository(:postgres).adapter
-    end
-
-    describe '#upgrade_model_storage' do
-      before do
-        @repository = mock('repository', :kind_of? => true, :name => :postgres)
-        @model      = mock('model', :kind_of? => true, :storage_name => 'models')
-        @property   = mock('property', :kind_of? => true, :model => @model, :serial? => true, :field => 'property')
-
-        @model.should_receive(:properties).with(:postgres).any_number_of_times.and_return([@property])
-
-        @command    = mock('command')
-        @connection = mock('connection', :create_command => @command, :close => true)
-        @result     = mock('result', :to_i => 0)
-
-        DataObjects::Connection.stub!(:new).and_return(@connection)
-
-        @adapter.stub!(:execute).and_return(@result)
-        @adapter.stub!(:storage_exists?).and_return(true)
-        @adapter.stub!(:query).and_return([ 0 ])
-
-        @original_method = @adapter.class.superclass.instance_method(:upgrade_model_storage)
-        @adapter.class.superclass.send(:define_method, :upgrade_model_storage) { |repository, model| }
-      end
-
-      after do
-        method = @original_method
-        @adapter.class.superclass.send(:define_method, :upgrade_model_storage) do |*args|
-          method.bind(self).call(*args)
-        end
-      end
-
-      it 'should check to make sure the sequences exist' do
-        statement = %q[SELECT COUNT(*) FROM "information_schema"."sequences" WHERE "sequence_name" = ? AND "sequence_schema" = current_schema()]
-        @adapter.should_receive(:query).with(statement, 'models_property_seq').and_return([ 0 ])
-        @adapter.upgrade_model_storage(@repository, @model)
-      end
-
-      it 'should add sequences' do
-        statement = %q[CREATE SEQUENCE "models_property_seq"]
-        @adapter.should_receive(:execute).with(statement)
-        @adapter.upgrade_model_storage(@repository, @model)
-      end
-
-      it 'should execute the superclass upgrade_model_storage' do
-        rv = mock('inside super')
-        @adapter.class.superclass.send(:define_method, :upgrade_model_storage) { |repository, model| rv }
-        @adapter.upgrade_model_storage(@repository, @model).should == rv
-      end
-    end
-
-    describe '#create_model_storage' do
-      before do
-        @repository = mock('repository', :kind_of? => true, :name => :postgres)
-        @model      = mock('model', :kind_of? => true, :storage_name => 'models')
-        @property   = mock('property', :kind_of? => true, :model => @model, :serial? => true, :field => 'property')
-
-        @model.should_receive(:properties).with(:postgres).any_number_of_times.and_return([@property])
-
-        @adapter.stub!(:execute).and_return(@result)
-        @adapter.stub!(:storage_exists?).and_return(true)
-        @adapter.stub!(:query).and_return([ 0 ])
-
-        @original_method = @adapter.class.superclass.instance_method(:create_table_statement)
-        @adapter.class.superclass.send(:define_method, :create_table_statement) {}
-      end
-
-      after do
-        method = @original_method
-        @adapter.class.superclass.send(:define_method, :create_table_statement) do |*args|
-          method.bind(self).call(*args)
-        end
-      end
-
-      it 'should check to make sure the sequences exist' do
-        statement = %q[SELECT COUNT(*) FROM "information_schema"."sequences" WHERE "sequence_name" = ? AND "sequence_schema" = current_schema()]
-        @adapter.should_receive(:query).with(statement, 'models_property_seq').and_return([ 0 ])
-        @adapter.create_model_storage(@repository, @model)
-      end
-
-      it 'should add sequences' do
-        statement = %q[CREATE SEQUENCE "models_property_seq"]
-        @adapter.should_receive(:execute).with(statement)
-        @adapter.create_model_storage(@repository, @model)
-      end
-
-      it 'should execute the superclass upgrade_model_storage' do
-        rv = mock('inside super')
-        @adapter.class.superclass.send(:define_method, :create_table_statement) { |repository, model| rv }
-        @adapter.create_table_statement(@repository, @model).should == rv
-      end
-    end
-
-    describe '#destroy_model_storage' do
-      before do
-        @repository = mock('repository', :kind_of? => true, :name => :postgres)
-        @model      = mock('model', :kind_of? => true, :storage_name => 'models')
-        @property   = mock('property', :kind_of? => true, :model => @model, :serial? => true, :field => 'property')
-
-        @model.should_receive(:properties).with(:postgres).any_number_of_times.and_return([@property])
-
-        @original_method = @adapter.class.superclass.instance_method(:destroy_model_storage)
-        @adapter.class.superclass.send(:define_method, :destroy_model_storage) {}
-      end
-
-      after do
-        method = @original_method
-        @adapter.class.superclass.send(:define_method, :destroy_model_storage) do |*args|
-          method.bind(self).call(*args)
-        end
-      end
-
-      it 'should not execute the superclass destroy_model_storage if the storage does not exist' do
-        rv = mock('inside super')
-        @adapter.class.superclass.send(:define_method, :destroy_model_storage) { |repository, model| rv }
-        @adapter.destroy_model_storage(@repository, @model).should_not == rv
-      end
-
-      it 'should execute the superclass destroy_model_storage if the storage exists' do
-        rv = mock('inside super')
-        @adapter.class.superclass.send(:define_method, :destroy_model_storage) { |repository, model| rv }
-        @adapter.stub!(:storage_exists?).and_return(true)
-
-        @adapter.destroy_model_storage(@repository, @model).should == rv
-      end
-    end
-  end
-end

data/spec/unit/associations/many_to_many_spec.rb

@@ -1,32 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe DataMapper::Associations::ManyToMany do
-
-  load_models_for_metaphor :vehicles, :content
-
-  it 'should allow a declaration' do
-    lambda do
-      class ::Supplier
-        has n, :manufacturers, :through => Resource
-      end
-    end.should_not raise_error
-  end
-
-  it 'should handle models inside modules' do
-    lambda do
-      module ::Content
-        class Dialect
-          has n, :locales, :through => Resource, :class_name => "Language::Locale"
-        end
-
-        class Locale
-          has n, :dialects, :through => Resource, :class_name => "Language::Dialect"
-        end
-      end
-    end.should_not raise_error
-  end
-
-end
-
-describe DataMapper::Associations::ManyToMany::Proxy do
-end

data/spec/unit/associations/many_to_one_spec.rb

@@ -1,159 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe DataMapper::Associations::ManyToOne do
-
-  load_models_for_metaphor :vehicles
-
-  it 'should allow a declaration' do
-    lambda do
-      class ::Vehicle
-        belongs_to :manufacturer
-      end
-    end.should_not raise_error
-  end
-end
-
-describe DataMapper::Associations::ManyToOne::Proxy do
-
-  load_models_for_metaphor :vehicles
-
-  before do
-    @child        = mock('child', :kind_of? => true)
-    @parent       = mock('parent', :nil? => false, :new_record? => false)
-    @relationship = mock('relationship', :kind_of? => true, :get_parent => @parent, :attach_parent => nil)
-    @association  = DataMapper::Associations::ManyToOne::Proxy.new(@relationship, @child)
-
-    @association.replace(@parent)
-  end
-
-  it 'should provide #replace' do
-    @association.should respond_to(:replace)
-  end
-
-  describe '#class' do
-    it 'should be forwarded to parent' do
-      @parent.should_receive(:class).and_return(Manufacturer)
-      @association.class.should == Manufacturer
-    end
-  end
-
-  describe '#replace' do
-    before do
-      @other = mock('other parent')
-    end
-
-    before do
-      @relationship.should_receive(:attach_parent).with(@child, @other)
-    end
-
-    it 'should remove the resource from the collection' do
-      @association.should == @parent
-      @association.replace(@other)
-      @association.should == @other
-    end
-
-    it 'should not automatically save that the resource was removed from the association' do
-      @other.should_not_receive(:save)
-      @association.replace(@other)
-    end
-
-    it 'should return the association' do
-      @association.replace(@other).object_id.should == @association.object_id
-    end
-  end
-
-  it 'should provide #save' do
-    @association.should respond_to(:replace)
-  end
-
-  describe '#save' do
-    describe 'when the parent is nil' do
-      before do
-        @parent.stub!(:nil?).and_return(true)
-      end
-
-      it 'should not save the parent' do
-        @association.save
-      end
-
-      it 'should return false' do
-        @association.save.should == false
-      end
-    end
-
-    describe 'when the parent is not a new record' do
-      before do
-        @parent.should_receive(:new_record?).with(no_args).and_return(false)
-      end
-
-      it 'should not save the parent' do
-        @parent.should_not_receive(:save)
-        @association.save
-      end
-
-      it 'should return true' do
-        @association.save.should == true
-      end
-    end
-
-    describe 'when the parent is a new record' do
-      before do
-        @parent.should_receive(:new_record?).with(no_args).and_return(true)
-      end
-
-      it 'should save the parent' do
-        @relationship.should_receive(:with_repository).and_yield
-        @parent.should_receive(:save).with(no_args)
-        @association.save
-      end
-
-      it 'should return the result of the save' do
-        child_key = mock("child_key")
-        child_key.should_receive(:set).and_return(true)
-        parent_key = mock("parent_key")
-        parent_key.should_receive(:get).and_return(1)
-        @relationship.should_receive(:with_repository).and_yield
-        @relationship.should_receive(:child_key).and_return(child_key)
-        @relationship.should_receive(:parent_key).and_return(parent_key)
-        save_results = mock('save results')
-        @parent.should_receive(:save).with(no_args).and_return(save_results)
-        @association.save.object_id.should == save_results.object_id
-      end
-    end
-  end
-
-  it 'should provide #reload' do
-    @association.should respond_to(:reload)
-  end
-
-  describe '#reload' do
-    before(:each) do
-      @mock_parent = mock('#reload test parent')
-      @association.replace(@mock_parent)
-    end
-
-    it 'should set the @parent ivar to nil' do
-      @association.__send__(:parent).should == @mock_parent # Sanity check.
-
-      # We can't test the value of the instance variable since
-      # #instance_variable_get will be run on the @parent (thanks to
-      # Proxy#method_missing). Instead, test that Relationship#get_parent is
-      # run -- if @parent wasn't set to nil, this expectation should fail.
-      @relationship.should_receive(:get_parent).once.and_return(@mock_parent)
-      @association.reload
-
-      # Trigger #get_parent on the relationship.
-      @association.__send__(:parent)
-    end
-
-    it 'should not change the foreign key in the child' do
-      @relationship.should_not_receive(:attach_parent)
-      @association.reload
-    end
-
-    it 'should return self' do
-      @association.reload.should be_kind_of(DataMapper::Associations::ManyToOne::Proxy)
-      @association.reload.object_id.should == @association.object_id
-    end
-  end
-end

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