ghost_dm-core 1.3.0.beta

data/spec/semipublic/resource/state/clean_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+describe DataMapper::Resource::PersistenceState::Clean do
+  before :all do
+    class ::Author
+      include DataMapper::Resource
+
+      property :id,     HugeInteger, :key => true, :default => 1
+      property :name,   String
+      property :active, Boolean,     :default => true
+      property :coding, Boolean,     :default => true
+
+      belongs_to :parent, self, :required => false
+      has n, :children, self, :inverse => :parent
+    end
+    DataMapper.finalize
+
+    @model = Author
+  end
+
+  before do
+    @resource = @model.create(:name => 'Dan Kubb')
+
+    @state = @resource.persistence_state
+    @state.should be_kind_of(DataMapper::Resource::PersistenceState::Clean)
+  end
+
+  after do
+    @model.destroy!
+  end
+
+  [ :commit, :rollback ].each do |method|
+    describe "##{method}" do
+      subject { @state.send(method) }
+
+      supported_by :all do
+        it 'should be a no-op' do
+          should equal(@state)
+        end
+      end
+    end
+  end
+
+  describe '#delete' do
+    subject { @state.delete }
+
+    supported_by :all do
+      it 'should return a Deleted state' do
+        should eql(DataMapper::Resource::PersistenceState::Deleted.new(@resource))
+      end
+    end
+  end
+
+  describe '#get' do
+    it_should_behave_like 'Resource::PersistenceState::Persisted#get'
+  end
+
+  describe '#set' do
+    subject { @state.set(@key, @value) }
+
+    supported_by :all do
+      describe 'with attributes that make the resource dirty' do
+        before do
+          @key   = @model.properties[:name]
+          @value = nil
+        end
+
+        it_should_behave_like 'A method that delegates to the superclass #set'
+
+        it 'should return a Dirty state' do
+          should eql(DataMapper::Resource::PersistenceState::Dirty.new(@resource))
+        end
+      end
+
+      describe 'with attributes that keep the resource clean' do
+        before do
+          @key   = @model.properties[:name]
+          @value = 'Dan Kubb'
+        end
+
+        it_should_behave_like 'A method that does not delegate to the superclass #set'
+
+        it 'should return a Clean state' do
+          should equal(@state)
+        end
+      end
+    end
+  end
+end

data/spec/semipublic/resource/state/deleted_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+describe DataMapper::Resource::PersistenceState::Deleted do
+  before :all do
+    class ::Author
+      include DataMapper::Resource
+
+      property :id,     HugeInteger, :key => true, :default => 1
+      property :name,   String
+      property :active, Boolean,     :default => true
+      property :coding, Boolean,     :default => true
+
+      belongs_to :parent, self, :required => false
+      has n, :children, self, :inverse => :parent
+    end
+
+    DataMapper.finalize
+    @model = Author
+  end
+
+  before do
+    @resource = @model.create(:name => 'Dan Kubb')
+
+    @state = DataMapper::Resource::PersistenceState::Deleted.new(@resource)
+  end
+
+  after do
+    @model.destroy!
+  end
+
+  describe '#commit' do
+    subject { @state.commit }
+
+    supported_by :all do
+      it 'should return an Immutable state' do
+        should eql(DataMapper::Resource::PersistenceState::Immutable.new(@resource))
+      end
+
+      it 'should delete the resource' do
+        subject
+        @model.get(*@resource.key).should be_nil
+      end
+
+      it 'should remove the resource from the identity map' do
+        identity_map = @resource.repository.identity_map(@model)
+        method(:subject).should change { identity_map.dup }.from(@resource.key => @resource).to({})
+      end
+    end
+  end
+
+  describe '#delete' do
+    subject { @state.delete }
+
+    supported_by :all do
+      it 'should be a no-op' do
+        should equal(@state)
+      end
+    end
+  end
+
+  describe '#get' do
+    it_should_behave_like 'Resource::PersistenceState::Persisted#get'
+  end
+
+  describe '#set' do
+    subject { @state.set(@key, @value) }
+
+    supported_by :all do
+      before do
+        @key   = @model.properties[:name]
+        @value = @key.get!(@resource)
+      end
+
+      it 'should raise an exception' do
+        method(:subject).should raise_error(DataMapper::ImmutableDeletedError, 'Deleted resource cannot be modified')
+      end
+    end
+  end
+end

data/spec/semipublic/resource/state/dirty_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+describe DataMapper::Resource::PersistenceState::Dirty do
+  before :all do
+    class ::Author
+      include DataMapper::Resource
+
+      property :id,     HugeInteger, :key => true, :default => 1
+      property :name,   String
+      property :active, Boolean,     :default => true
+      property :coding, Boolean,     :default => true
+
+      belongs_to :parent, self, :required => false
+      has n, :children, self, :inverse => :parent
+    end
+
+    DataMapper.finalize
+
+    @model = Author
+  end
+
+  before do
+    @parent = @model.create(:name => 'Jane Doe')
+
+    @resource = @model.create(:id => 2, :name => 'Dan Kubb', :parent => @parent)
+    @resource.attributes = { :name => 'John Doe' }
+
+    @state = @resource.persistence_state
+    @state.should be_kind_of(DataMapper::Resource::PersistenceState::Dirty)
+  end
+
+  after do
+    @model.destroy!
+  end
+
+  describe '#commit' do
+    subject { @state.commit }
+
+    supported_by :all do
+      context 'with valid attributes' do
+        let(:state) { @state }
+
+        before do
+          @new_id = @resource.id = @resource.id.succ
+        end
+
+        it 'should return a Clean state' do
+          should eql(DataMapper::Resource::PersistenceState::Clean.new(@resource))
+        end
+
+        it 'should set the child key if the parent key changes' do
+          original_id = @parent.id
+          @parent.update(:id => 42).should be(true)
+          method(:subject).should change(@resource, :parent_id).from(original_id).to(42)
+        end
+
+        it 'should update the resource' do
+          subject
+          @model.get!(*@resource.key).should == @resource
+        end
+
+        it 'should update the resource to the identity map if the key changed' do
+          identity_map = @resource.repository.identity_map(@model)
+          identity_map.should == { @resource.key => @resource }
+          subject
+          identity_map.should == { [ @new_id ] => @resource }
+        end
+      end
+
+      context 'with invalid attributes' do
+        before do
+          @resource.coding = 'invalid'
+        end
+
+        it 'should raise InvalidValueError' do
+          expect { subject }.to(raise_error(DataMapper::Property::InvalidValueError) do |error|
+            error.property.should == Author.coding
+          end)
+        end
+
+        it 'should not change the identity map' do
+          identity_map = @resource.repository.identity_map(@model).dup
+          expect { subject }.to raise_error
+          identity_map.should == @resource.repository.identity_map(@model)
+        end
+      end
+    end
+  end
+
+  describe '#delete' do
+    subject { @state.delete }
+
+    supported_by :all do
+      before do
+        @resource.children = [ @resource.parent = @resource ]
+      end
+
+      it_should_behave_like 'It resets resource state'
+
+      it 'should return a Deleted state' do
+        should eql(DataMapper::Resource::PersistenceState::Deleted.new(@resource))
+      end
+    end
+  end
+
+  describe '#get' do
+    before do
+      @loaded_value = 'John Doe'
+    end
+
+    it_should_behave_like 'Resource::PersistenceState::Persisted#get'
+  end
+
+  describe '#rollback' do
+    subject { @state.rollback }
+
+    supported_by :all do
+      before do
+        @resource.children = [ @resource.parent = @resource ]
+      end
+
+      it_should_behave_like 'It resets resource state'
+
+      it 'should return a Clean state' do
+        should eql(DataMapper::Resource::PersistenceState::Clean.new(@resource))
+      end
+    end
+  end
+
+  describe '#set' do
+    subject { @state.set(@key, @value) }
+
+    supported_by :all do
+      describe 'with attributes that keep the resource dirty' do
+        before do
+          @key   = @model.properties[:id]
+          @value = @key.get!(@resource)
+        end
+
+        it_should_behave_like 'A method that delegates to the superclass #set'
+
+        it 'should return a Dirty state' do
+          should equal(@state)
+        end
+
+        its(:original_attributes) { should == { @model.properties[:name] => 'Dan Kubb' } }
+      end
+
+      describe 'with attributes that make the resource clean' do
+        before do
+          @key   = @model.properties[:name]
+          @value = 'Dan Kubb'
+        end
+
+        it_should_behave_like 'A method that delegates to the superclass #set'
+
+        it 'should return a Clean state' do
+          should eql(DataMapper::Resource::PersistenceState::Clean.new(@resource))
+        end
+      end
+    end
+  end
+end

data/spec/semipublic/resource/state/immutable_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+describe DataMapper::Resource::PersistenceState::Immutable do
+  before :all do
+    class ::Author
+      include DataMapper::Resource
+
+      property :id,     Serial
+      property :name,   String
+      property :active, Boolean, :default => true
+      property :coding, Boolean, :default => true
+
+      belongs_to :parent, self, :required => false
+    end
+
+    DataMapper.finalize
+
+    @model = Author
+  end
+
+  before do
+    @parent = @model.create(:name => 'John Doe')
+
+    @resource  = @model.create(:name => 'Dan Kubb', :parent => @parent)
+    attributes = Hash[ @model.key.zip(@resource.key) ]
+    @resource  = @model.first(attributes.merge(:fields => [ :name, :parent_id ]))
+
+    @state = @resource.persistence_state
+    @state.should be_kind_of(DataMapper::Resource::PersistenceState::Immutable)
+  end
+
+  after do
+    @model.destroy!
+  end
+
+  describe '#commit' do
+    subject { @state.commit }
+
+    supported_by :all do
+      it 'should be a no-op' do
+        should equal(@state)
+      end
+    end
+  end
+
+  describe '#delete' do
+    subject { @state.delete }
+
+    supported_by :all do
+      it 'should raise an exception' do
+        method(:subject).should raise_error(DataMapper::ImmutableError, 'Immutable resource cannot be deleted')
+      end
+    end
+  end
+
+  describe '#get' do
+    subject { @state.get(@key) }
+
+    supported_by :all do
+      describe 'with an unloaded property' do
+        before do
+          @key = @model.properties[:id]
+        end
+
+        it 'should raise an exception' do
+          method(:subject).should raise_error(DataMapper::ImmutableError, 'Immutable resource cannot be lazy loaded')
+        end
+      end
+
+      describe 'with an unloaded relationship' do
+        before do
+          @key = @model.relationships[:parent]
+        end
+
+        it 'should return value' do
+          should == @parent
+        end
+      end
+
+      describe 'with a loaded subject' do
+        before do
+          @key = @model.properties[:name]
+        end
+
+        it 'should return value' do
+          should == 'Dan Kubb'
+        end
+      end
+    end
+  end
+
+  describe '#set' do
+    before do
+      @key   = @model.properties[:name]
+      @value = @key.get!(@resource)
+    end
+
+    subject { @state.set(@key, @value) }
+
+    supported_by :all do
+      it 'should raise an exception' do
+        method(:subject).should raise_error(DataMapper::ImmutableError, 'Immutable resource cannot be modified')
+      end
+    end
+  end
+end

data/spec/semipublic/resource/state/transient_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+describe DataMapper::Resource::PersistenceState::Transient do
+  before :all do
+    class ::Author
+      include DataMapper::Resource
+
+      property :id,          Serial
+      property :name,        String
+      property :age,         Integer
+      property :description, Text,    :default => lambda { |resource, property| resource.name }
+      property :active,      Boolean, :default => true
+      property :coding,      Boolean, :default => true
+
+      belongs_to :parent, self, :required => false
+      has n, :children, self, :inverse => :parent
+
+      belongs_to :with_default, self, :required => false, :default => proc { first(:name => 'John Doe') }
+    end
+
+    DataMapper.finalize
+
+    @model = Author
+  end
+
+  before do
+    @parent   = @model.create(:name => 'John Doe')
+    @resource = @model.new(:name => 'Dan Kubb', :coding => false, :parent => @parent)
+
+    @state = @resource.persistence_state
+    @state.should be_kind_of(DataMapper::Resource::PersistenceState::Transient)
+  end
+
+  after do
+    @model.destroy!
+  end
+
+  describe '#commit' do
+    subject { @state.commit }
+
+    supported_by :all do
+      it 'should return the expected Clean state' do
+        should eql(DataMapper::Resource::PersistenceState::Clean.new(@resource))
+      end
+
+      it 'should set the serial property' do
+        method(:subject).should change(@resource, :id).from(nil)
+      end
+
+      it 'should set the child key if the parent key changes' do
+        # SqlServer does not allow updating IDENTITY columns.
+        if defined?(DataMapper::Adapters::SqlserverAdapter) &&
+           @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter)
+          return
+        end
+
+        original_id = @parent.id
+        @parent.update(:id => 42).should be(true)
+        method(:subject).should change(@resource, :parent_id).from(original_id).to(42)
+      end
+
+      it 'should set default values' do
+        method(:subject).should change { @model.relationships[:with_default].get!(@resource) }.from(nil).to(@parent)
+      end
+
+      it 'should not set default values when they are already set' do
+        method(:subject).should_not change(@resource, :coding)
+      end
+
+      it 'should create the resource' do
+        subject
+        @model.get(*@resource.key).should == @resource
+      end
+
+      it 'should reset original attributes' do
+        original_attributes = {
+          @model.properties[:name]      => nil,
+          @model.properties[:coding]    => nil,
+          @model.properties[:parent_id] => nil,
+          @model.relationships[:parent] => nil,
+        }
+
+        expect do
+          @resource.persistence_state = subject
+        end.should change { @resource.original_attributes.dup }.from(original_attributes).to({})
+      end
+
+      it 'should add the resource to the identity map' do
+        DataMapper.repository do |repository|
+          identity_map = repository.identity_map(@model)
+          identity_map.should be_empty
+          subject
+          identity_map.should == { @parent.key => @parent, @resource.key => @resource }
+        end
+      end
+    end
+  end
+
+  [ :delete, :rollback ].each do |method|
+    describe "##{method}" do
+      subject { @state.send(method) }
+
+      supported_by :all do
+        it 'should be a no-op' do
+          should equal(@state)
+        end
+      end
+    end
+  end
+
+  describe '#get' do
+    subject { @state.get(@key) }
+
+    supported_by :all do
+      describe 'with a set value' do
+        before do
+          @key = @model.properties[:coding]
+          @key.should be_loaded(@resource)
+        end
+
+        it 'should return value' do
+          should be(false)
+        end
+
+        it 'should be idempotent' do
+          should equal(subject)
+        end
+      end
+
+      describe 'with an unset value and no default value' do
+        before do
+          @key = @model.properties[:age]
+          @key.should_not be_loaded(@resource)
+          @key.should_not be_default
+        end
+
+        it 'should return nil' do
+          should be_nil
+        end
+
+        it 'should be idempotent' do
+          should equal(subject)
+        end
+      end
+
+      describe 'with an unset value and a default value' do
+        before do
+          @key = @model.properties[:description]
+          @key.should_not be_loaded(@resource)
+          @key.should be_default
+        end
+
+        it 'should return the name' do
+          should == 'Dan Kubb'
+        end
+
+        it 'should be idempotent' do
+          should equal(subject)
+        end
+      end
+    end
+  end
+end