sbf-dm-core 1.3.0.beta

data/spec/semipublic/resource/state_spec.rb

@@ -0,0 +1,230 @@
+require_relative '../../spec_helper'
+
+describe DataMapper::Resource::PersistenceState do
+  before :all do
+    class ::Author
+      include DataMapper::Resource
+
+      property :id,      Serial
+      property :name,    String
+      property :private, Boolean, :accessor => :private
+
+      belongs_to :parent, self, :required => false
+    end
+
+    DataMapper.finalize
+
+    @model = Author
+  end
+
+  before do
+    @resource = @model.new(:name => 'Dan Kubb')
+
+    @state = DataMapper::Resource::PersistenceState.new(@resource)
+  end
+
+  describe '.new' do
+    subject { DataMapper::Resource::PersistenceState.new(@resource) }
+
+    it { is_expected.to be_kind_of(DataMapper::Resource::PersistenceState) }
+  end
+
+  describe '#==' do
+    subject { @state == @other }
+
+    supported_by :all do
+      describe 'with the same class and resource' do
+        before do
+          @other = DataMapper::Resource::PersistenceState.new(@resource)
+        end
+
+        it { is_expected.to be(true) }
+
+        it 'Is symmetric' do
+          is_expected.to eq(@other == @state)
+        end
+      end
+
+      describe 'with the same class and different resource' do
+        before do
+          @other = DataMapper::Resource::PersistenceState.new(@model.new)
+        end
+
+        it { is_expected.to be(false) }
+
+        it 'Is symmetric' do
+          is_expected.to eq(@other == @state)
+        end
+      end
+
+      describe 'with a different class and the same resource' do
+        before do
+          @other = DataMapper::Resource::PersistenceState::Clean.new(@resource)
+        end
+
+        it 'Is true for a subclass' do
+          is_expected.to be(true)
+        end
+
+        it 'Is symmetric' do
+          is_expected.to eq(@other == @state)
+        end
+      end
+
+      describe 'with a different class and different resource' do
+        before do
+          @other = DataMapper::Resource::PersistenceState::Clean.new(@model.new)
+        end
+
+        it { is_expected.to be(false) }
+
+        it 'Is symmetric' do
+          is_expected.to eq(@other == @state)
+        end
+      end
+    end
+  end
+
+  [ :commit, :delete, :rollback ].each do |method|
+    describe "##{method}" do
+      subject { @state.send(method) }
+
+      it 'Raises an exception' do
+        expect { method(:subject) }.to raise_error(NotImplementedError, "DataMapper::Resource::PersistenceState##{method} should be implemented")
+      end
+    end
+  end
+
+  describe '#eql?' do
+    subject { @state.eql?(@other) }
+
+    supported_by :all do
+      describe 'with the same class and resource' do
+        before do
+          @other = DataMapper::Resource::PersistenceState.new(@resource)
+        end
+
+        it { is_expected.to be(true) }
+
+        it 'Is symmetric' do
+          is_expected.to eq @other.eql?(@state)
+        end
+      end
+
+      describe 'with the same class and different resource' do
+        before do
+          @other = DataMapper::Resource::PersistenceState.new(@model.new)
+        end
+
+        it { is_expected.to be(false) }
+
+        it 'Is symmetric' do
+          is_expected.to eq @other.eql?(@state)
+        end
+      end
+
+      describe 'with a different class and the same resource' do
+        before do
+          @other = DataMapper::Resource::PersistenceState::Clean.new(@resource)
+        end
+
+        it { is_expected.to be(false) }
+
+        it 'Is symmetric' do
+          is_expected.to eq @other.eql?(@state)
+        end
+      end
+
+      describe 'with a different class and different resource' do
+        before do
+          @other = DataMapper::Resource::PersistenceState::Clean.new(@model.new)
+        end
+
+        it { is_expected.to be(false) }
+
+        it 'Is symmetric' do
+          is_expected.to eq @other.eql?(@state)
+        end
+      end
+    end
+  end
+
+  describe '#get' do
+    subject { @state.get(@key) }
+
+    describe 'with a Property subject' do
+      before do
+        @key = @model.properties[:name]
+      end
+
+      it 'Returns the value' do
+        is_expected.to eq 'Dan Kubb'
+      end
+    end
+
+    describe 'with a Relationship subject' do
+      supported_by :all do
+        before do
+          # set the association
+          @resource.parent = @resource
+
+          @key = @model.relationships[:parent]
+        end
+
+        it 'Returns the association' do
+          is_expected.to eq @resource
+        end
+      end
+    end
+  end
+
+  describe '#hash' do
+    subject { @state.hash }
+
+    it { is_expected.to eq @state.class.hash ^ @resource.hash }
+  end
+
+  describe '#resource' do
+    subject { @state.resource }
+
+    it 'Returns the resource' do
+      is_expected.to equal(@resource)
+    end
+  end
+
+  describe '#set' do
+    subject { @state.set(@key, @value) }
+
+    describe 'with a Property subject' do
+      before do
+        @key   = @model.properties[:name]
+        @value = 'John Doe'
+      end
+
+      it 'Returns a state object' do
+        is_expected.to be_kind_of(DataMapper::Resource::PersistenceState)
+      end
+
+      it 'Change the object attributes' do
+        expect { method(:subject) }.to change(@resource, :attributes).from(:name => 'Dan Kubb').to(:name => 'John Doe')
+      end
+    end
+
+    describe 'with a Relationship subject' do
+      supported_by :all do
+        before do
+          @key   = @model.relationships[:parent]
+          @value = @resource
+        end
+
+        it 'Returns a state object' do
+          is_expected.to be_kind_of(DataMapper::Resource::PersistenceState)
+        end
+
+        it 'Changes the object relationship' do
+          expect { method(:subject) }.to change(@resource, :parent).from(nil).to(@resource)
+        end
+      end
+    end
+  end
+end

data/spec/semipublic/resource_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../spec_helper'
+
+describe DataMapper::Resource do
+  before :all do
+    class ::User
+      include DataMapper::Resource
+
+      property :name,        String, :key => true
+      property :age,         Integer
+      property :description, Text
+    end
+
+    @user_model = User
+  end
+
+  supported_by :all do
+    before :all do
+      @user = @user_model.create(:name => 'dbussink', :age => 25, :description => "Test")
+    end
+
+    it_behaves_like 'A semipublic Resource'
+  end
+end

data/spec/semipublic/shared/condition_shared_spec.rb

@@ -0,0 +1,9 @@
+shared_examples 'A valid query condition' do
+  before :all do
+    raise '+@comp+ should be defined in before block' unless instance_variable_get(:@comp)
+  end
+
+  it 'is valid' do
+    expect(@comp).to be_valid
+  end
+end

data/spec/semipublic/shared/resource_shared_spec.rb

@@ -0,0 +1,198 @@
+shared_examples 'A semipublic Resource' do
+  before :all do
+    %w[ @user_model @user ].each do |ivar|
+      raise "+#{ivar}+ should be defined in before block" unless instance_variable_get(ivar)
+    end
+  end
+
+  it { expect(@user).to respond_to(:attribute_dirty?) }
+
+  describe '#attribute_dirty?' do
+    describe 'on a non-dirty record' do
+      it { expect(@user.attribute_dirty?(:age)).to be(false) }
+    end
+
+    describe 'on a dirty record' do
+      before { @user.age = 100 }
+
+      it { expect(@user.attribute_dirty?(:age)).to be(true) }
+    end
+
+    describe 'on a new record' do
+      before { @user = @user_model.new }
+
+      it { expect(@user.attribute_dirty?(:age)).to be(false) }
+    end
+  end
+
+  it { expect(@user).to respond_to(:dirty_attributes) }
+
+  describe '#dirty_attributes' do
+    describe 'on a saved/clean record' do
+      it { expect(@user.dirty_attributes).to be_empty }
+    end
+
+    describe 'on a saved/dirty record' do
+      before { @user.age = 100 }
+
+      it { expect(@user.dirty_attributes).to eq({@user_model.properties[:age] => 100}) }
+    end
+
+    describe 'on an saved/set/unset record' do
+      before do
+        @user.age = 100
+        @user.age = 25
+      end
+
+      it { expect(@user.dirty_attributes).to be_empty }
+    end
+
+    describe 'on an saved/unchanged record' do
+      before do
+        @user.age = 25
+      end
+
+      it { expect(@user.dirty_attributes).to be_empty }
+    end
+
+    describe 'on a new/clean record' do
+      before { @user = @user_model.new }
+
+      it { expect(@user.dirty_attributes).to be_empty }
+    end
+
+    describe 'on a new/dirty record' do
+      before { @user = @user_model.new(:age => 100) }
+
+      it { expect(@user.original_attributes).to eq({@user_model.properties[:age] => nil}) }
+    end
+
+    describe 'on an new/set/unset record' do
+      before do
+        @user = @user_model.new(:age => 100)
+        @user.age = nil
+      end
+
+      it { expect(@user.dirty_attributes).to eq({@user_model.properties[:age] => nil}) }
+    end
+
+    describe 'on an new/unchanged record' do
+      before do
+        @user = @user_model.new(:age => nil)
+      end
+
+      it { expect(@user.dirty_attributes).to eq({@user_model.properties[:age] => nil}) }
+    end
+  end
+
+  it { expect(@user).to respond_to(:original_attributes) }
+
+  describe '#original_attributes' do
+    describe 'on a saved/clean record' do
+      it { expect(@user.original_attributes).to be_empty }
+    end
+
+    describe 'on a saved/dirty record' do
+      before { @user.age = 100 }
+
+      it { expect(@user.original_attributes).to eq({@user_model.properties[:age] => 25}) }
+    end
+
+    describe 'on an saved/set/unset record' do
+      before do
+        @user.age = 100
+        @user.age = 25
+      end
+
+      it { expect(@user.original_attributes).to be_empty }
+    end
+
+    describe 'on an saved/unchanged record' do
+      before do
+        @user.age = 25
+      end
+
+      it { expect(@user.original_attributes).to be_empty }
+    end
+
+    describe 'on a new/clean record' do
+      before { @user = @user_model.new }
+
+      it { expect(@user.original_attributes).to be_empty }
+    end
+
+    describe 'on a new/dirty record' do
+      before { @user = @user_model.new(:age => 100) }
+
+      it { expect(@user.original_attributes).to eq({@user_model.properties[:age] => nil}) }
+    end
+
+    describe 'on an new/set/unset record' do
+      before do
+        @user = @user_model.new(:age => 100)
+        @user.age = nil
+      end
+
+      it { expect(@user.original_attributes).to eq({@user_model.properties[:age] => nil}) }
+    end
+
+    describe 'on an new/unchanged record' do
+      before do
+        @user = @user_model.new(:age => nil)
+      end
+
+      it { expect(@user.original_attributes).to eq({@user_model.properties[:age] => nil}) }
+    end
+  end
+
+  it { expect(@user).to respond_to(:repository) }
+
+  describe '#repository' do
+    before :all do
+      class ::Statistic
+        include DataMapper::Resource
+
+        def self.default_repository_name
+          :alternate
+        end
+
+        property :id,    Serial
+        property :name,  String
+        property :value, Integer
+      end
+    end
+
+    with_alternate_adapter do
+      before :all do
+        if @user_model.respond_to?(:auto_migrate!)
+          # force the user model to be available in the alternate repository
+          @user_model.auto_migrate!(@adapter.name)
+        end
+      end
+
+      it 'Returns the default repository when nothing is specified' do
+        default_repository = DataMapper.repository(:default)
+        expect(@user_model.create(name: 'carl').repository).to eq default_repository
+        expect(@user_model.new.repository).to eq default_repository
+        expect(@user_model.get('carl').repository).to eq default_repository
+      end
+
+      it 'Returns the default repository for the model' do
+        statistic = Statistic.create(name: 'visits', value: 2)
+        expect(statistic.repository).to eq @repository
+        expect(Statistic.new.repository).to eq @repository
+        expect(Statistic.get(statistic.id).repository).to eq @repository
+      end
+
+      it 'Returns the repository defined by the current context' do
+        @repository.scope do
+          expect(@user_model.new.repository).to eq @repository
+          expect(@user_model.create(name: 'carl').repository).to eq @repository
+          expect(@user_model.get('carl').repository).to eq @repository
+        end
+
+        expect(@repository.scope { @user_model.get('carl') }.repository).to eq @repository
+      end
+    end
+  end
+end

data/spec/semipublic/shared/resource_state_shared_spec.rb

@@ -0,0 +1,91 @@
+shared_examples 'A method that delegates to the superclass #set' do
+  it 'Delegates to the superclass' do
+    # this is the only way I could think of to test if the
+    # superclass method is being called
+    DataMapper::Resource::PersistenceState.class_eval do
+      alias_method :original_set, :set
+      undef_method(:set)
+    end
+    expect { method(:subject) }.to raise_error(NoMethodError)
+    DataMapper::Resource::PersistenceState.class_eval do
+      alias_method :set, :original_set
+      undef_method(:original_set)
+    end
+  end
+end
+
+shared_examples 'A method that does not delegate to the superclass #set' do
+  it 'Delegates to the superclass' do
+    # this is the only way I could think of to test if the
+    # superclass method is not being called
+    DataMapper::Resource::PersistenceState.class_eval do
+      alias_method :original_set, :set
+      undef_method(:set)
+    end
+    expect { method(:subject) }.not_to raise_error
+    DataMapper::Resource::PersistenceState.class_eval do
+      alias_method :set, :original_set
+      undef_method(:original_set)
+    end
+  end
+end
+
+shared_examples 'It resets resource state' do
+  it 'Resets the dirty property' do
+    expect { method(:subject) }.to change(@resource, :name).from('John Doe').to('Dan Kubb')
+  end
+
+  it 'Resets the dirty m:1 relationship' do
+    expect { method(:subject) }.to change(@resource, :parent).from(@resource).to(nil)
+  end
+
+  it 'Resets the dirty 1:m relationship' do
+    expect { method(:subject) }.to change(@resource, :children).from([@resource]).to([])
+  end
+
+  it 'Clear original attributes' do
+    expect { method(:subject) }.to change { @resource.original_attributes.dup }.to({})
+  end
+end
+
+shared_examples 'Resource::PersistenceState::Persisted#get' do
+  subject { @state.get(@key) }
+
+  supported_by :all do
+    describe 'with an unloaded subject' do
+      before do
+        @key = @model.relationships[:parent]
+
+        # set the parent relationship
+        @resource.attributes = {@key => @resource}
+        expect(@resource).to be_dirty
+        expect(@resource.save).to be(true)
+
+        attributes = @model.key.zip(@resource.key).to_h
+        @resource = @model.first(attributes.merge(fields: @model.key))
+        @state = @state.class.new(@resource)
+
+        # make sure the subject is not loaded
+        expect(@key).not_to be_loaded(@resource)
+      end
+
+      it 'Lazy loads the value' do
+        expect(subject.key).to eq @resource.key
+      end
+    end
+
+    describe 'with a loaded subject' do
+      before do
+        @key = @model.properties[:name]
+        @loaded_value ||= 'Dan Kubb'
+
+        # make sure the subject is loaded
+        expect(@key).to be_loaded(@resource)
+      end
+
+      it 'Returns value' do
+        is_expected.to eq @loaded_value
+      end
+    end
+  end
+end

data/spec/semipublic/shared/subject_shared_spec.rb

@@ -0,0 +1,79 @@
+shared_examples 'A semipublic Subject' do
+  describe '#default?' do
+    describe 'with a default' do
+      subject { @subject_with_default.default? }
+
+      it { is_expected.to be(true) }
+    end
+
+    describe 'without a default' do
+      subject { @subject_without_default.default? }
+
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe '#default_for' do
+    describe 'without a default' do
+      subject { @subject_without_default.default_for(@resource) }
+
+      it 'Matches the default value' do
+        expect(DataMapper::Ext.blank?(subject)).to eq true
+      end
+
+      it 'Is used as a default for the subject accessor' do
+        is_expected.to eq @resource.__send__(@subject_without_default.name)
+      end
+
+      it 'Persists the value' do
+        expect(@resource.save).to be(true)
+        @resource = @resource.model.get!(*@resource.key)
+        expect(@resource.without_default).to eq subject
+      end
+    end
+
+    describe 'with a default value' do
+      subject { @subject_with_default.default_for(@resource) }
+
+      it 'Matches the default value' do
+        if @default_value.is_a?(DataMapper::Resource)
+          expect(subject.key).to eq @default_value.key
+        else
+          is_expected.to eq @default_value
+        end
+      end
+
+      it 'Is used as a default for the subject accessor' do
+        is_expected.to eq @resource.__send__(@subject_with_default.name)
+      end
+
+      it 'Persists the value' do
+        expect(@resource.save).to be(true)
+        @resource = @resource.model.get!(*@resource.key)
+        expect(@resource.with_default).to eq subject
+      end
+    end
+
+    describe 'with a default value responding to #call' do
+      subject { @subject_with_default_callable.default_for(@resource) }
+
+      it 'Matches the default value' do
+        if @default_value.is_a?(DataMapper::Resource)
+          expect(subject.key).to eq @default_value_callable.key
+        else
+          is_expected.to eq @default_value_callable
+        end
+      end
+
+      it 'Is used as a default for the subject accessor' do
+        is_expected.to eq @resource.__send__(@subject_with_default_callable.name)
+      end
+
+      it 'Persists the value' do
+        expect(@resource.save).to be(true)
+        @resource = @resource.model.get!(*@resource.key)
+        expect(@resource.with_default_callable).to eq subject
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'pathname'
+require 'rspec'
+require 'rspec/its'
+require 'dm-core/spec/setup'
+
+ENV['ADAPTER'] ||= 'in_memory'
+
+SPEC_ROOT = Pathname(__FILE__).dirname.expand_path
+LIB_ROOT  = "#{SPEC_ROOT.parent}/lib".freeze
+Pathname.glob("#{LIB_ROOT}/dm-core/spec/**/*.rb".to_s).each { |file| require file }
+Pathname.glob("#{SPEC_ROOT}/{lib,support,*/shared}/**/*.rb".to_s).each { |file| require file }
+
+RSpec.configure do |config|
+  config.extend(DataMapper::Spec::Adapters::Helpers)
+  config.include(DataMapper::Spec::PendingHelpers)
+  config.include(DataMapper::Spec::Helpers)
+
+  config.after :all do
+    DataMapper::Spec.cleanup_models
+  end
+
+  config.after :all do
+    # global ivar cleanup
+    DataMapper::Spec.remove_ivars(self, instance_variables.reject { |ivar| ivar[0, 2] == '@_' })
+  end
+
+  config.after :all do
+    # WTF: rspec holds a reference to the last match for some reason.
+    # When the object ivars are explicitly removed, this causes weird
+    # problems when rspec uses it (!).  Why rspec does this I have no
+    # idea because I cannot determine the intention from the code.
+    DataMapper::Spec.remove_ivars(RSpec::Matchers.last_matcher, %w(@expected))
+  end
+end

data/spec/support/core_ext/hash.rb

@@ -0,0 +1,10 @@
+class Hash
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+end