ardm-core 1.2.1

data/spec/semipublic/shared/resource_state_shared_spec.rb

@@ -0,0 +1,79 @@
+share_examples_for 'A method that delegates to the superclass #set' do
+  it 'should delegate 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 { alias_method :original_set, :set; undef_method(:set) }
+    method(:subject).should raise_error(NoMethodError)
+    DataMapper::Resource::PersistenceState.class_eval { alias_method :set, :original_set; undef_method(:original_set) }
+  end
+end
+
+share_examples_for 'A method that does not delegate to the superclass #set' do
+  it 'should delegate 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 { alias_method :original_set, :set; undef_method(:set) }
+    method(:subject).should_not raise_error(NoMethodError)
+    DataMapper::Resource::PersistenceState.class_eval { alias_method :set, :original_set; undef_method(:original_set) }
+  end
+end
+
+share_examples_for 'It resets resource state' do
+  it 'should reset the dirty property' do
+    method(:subject).should change(@resource, :name).from('John Doe').to('Dan Kubb')
+  end
+
+  it 'should reset the dirty m:1 relationship' do
+    method(:subject).should change(@resource, :parent).from(@resource).to(nil)
+  end
+
+  it 'should reset the dirty 1:m relationship' do
+    method(:subject).should change(@resource, :children).from([ @resource ]).to([])
+  end
+
+  it 'should clear original attributes' do
+    method(:subject).should change { @resource.original_attributes.dup }.to({})
+  end
+end
+
+share_examples_for '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 }
+        @resource.should be_dirty
+        @resource.save.should be(true)
+
+        attributes = Hash[ @model.key.zip(@resource.key) ]
+        @resource  = @model.first(attributes.merge(:fields => @model.key))
+        @state     = @state.class.new(@resource)
+
+        # make sure the subject is not loaded
+        @key.should_not be_loaded(@resource)
+      end
+
+      it 'should lazy load the value' do
+        subject.key.should == @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
+        @key.should be_loaded(@resource)
+      end
+
+      it 'should return value' do
+        should == @loaded_value
+      end
+    end
+  end
+end

data/spec/semipublic/shared/subject_shared_spec.rb

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

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--colour
+--loadby random
+--require ./spec/lib/rspec_immediate_feedback_formatter.rb
+--format Spec::Runner::Formatter::ImmediateFeedbackFormatter
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'pathname'
+require 'rubygems'
+require 'spec'
+require 'dm-core/spec/setup'
+
+ENV['ADAPTER'] ||= 'in_memory'
+
+SPEC_ROOT = Pathname(__FILE__).dirname.expand_path
+LIB_ROOT  = SPEC_ROOT.parent + 'lib'
+
+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 }
+
+Spec::Runner.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(Spec::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

data/spec/support/core_ext/inheritable_attributes.rb

@@ -0,0 +1,46 @@
+class Class
+  def class_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if defined?(@#{ivar})
+          return nil      if self.object_id == #{self.object_id}
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil?
+          @#{ivar} = DataMapper::Ext.try_dup(ivar)
+        end
+      RUBY
+
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end
+
+  def class_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:instance_writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+end

data/spec/support/properties/huge_integer.rb

@@ -0,0 +1,17 @@
+module DataMapper
+  class Property
+    class HugeInteger < DataMapper::Property::String
+      def load(value)
+        value.to_i unless value.nil?
+      end
+
+      def dump(value)
+        value.to_s unless value.nil?
+      end
+
+      def typecast(value)
+        load(value)
+      end
+    end
+  end
+end

data/spec/unit/array_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'dm-core/support/ext/array'
+require 'dm-core/support/mash'
+
+describe DataMapper::Ext::Array do
+  before :all do
+    @array = [ [ :a, [ 1 ] ], [ :b, [ 2 ] ], [ :c, [ 3 ] ] ].freeze
+  end
+
+  describe '.to_mash' do
+    before :all do
+      @return = DataMapper::Ext::Array.to_mash(@array)
+    end
+
+    it 'should return a Mash' do
+      @return.should be_kind_of(DataMapper::Mash)
+    end
+
+    it 'should return expected value' do
+      @return.should == { 'a' => [ 1 ], 'b' => [ 2 ], 'c' => [ 3 ] }
+    end
+  end
+end

data/spec/unit/blank_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'dm-core/support/ext/blank'
+
+describe 'DataMapper::Ext.blank?', Object do
+  it 'should be blank if it is nil' do
+    object = Object.new
+    class << object
+      def nil?; true end
+    end
+    DataMapper::Ext.blank?(object).should == true
+  end
+
+  it 'should be blank if it is empty' do
+    DataMapper::Ext.blank?({}).should == true
+    DataMapper::Ext.blank?([]).should == true
+  end
+
+  it 'should not be blank if not nil or empty' do
+    DataMapper::Ext.blank?(Object.new).should == false
+    DataMapper::Ext.blank?([nil]).should == false
+    DataMapper::Ext.blank?({ nil => 0 }).should == false
+  end
+end
+
+describe 'DataMapper::Ext.blank?', Numeric do
+  it 'should never be blank' do
+    DataMapper::Ext.blank?(1).should == false
+  end
+end
+
+describe 'DataMapper::Ext.blank?', NilClass do
+  it 'should always be blank' do
+    DataMapper::Ext.blank?(nil).should == true
+  end
+end
+
+describe 'DataMapper::Ext.blank?', TrueClass do
+  it 'should never be blank' do
+    DataMapper::Ext.blank?(true).should == false
+  end
+end
+
+describe 'DataMapper::Ext.blank?', FalseClass do
+  it 'should always be blank' do
+    DataMapper::Ext.blank?(false).should == true
+  end
+end
+
+describe 'DataMapper::Ext.blank?', String do
+  it 'should be blank if empty' do
+    DataMapper::Ext.blank?('').should == true
+  end
+
+  it 'should be blank if it only contains whitespace' do
+     DataMapper::Ext.blank?(' ').should == true
+     DataMapper::Ext.blank?(" \r \n \t ").should == true
+  end
+
+  it 'should not be blank if it contains non-whitespace' do
+    DataMapper::Ext.blank?(' a ').should == false
+  end
+end
+
+describe 'DataMapper::Ext.blank?', 'object with #blank?' do
+  subject { DataMapper::Ext.blank?(object) }
+
+  let(:return_value) { mock('Return Value')                    }
+  let(:object)       { mock('Object', :blank? => return_value) }
+
+  it 'returns the object#blank? result if supported' do
+    should equal(return_value)
+  end
+end

data/spec/unit/data_mapper/ordered_set/append_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/append_spec'
+
+describe 'DataMapper::OrderedSet#<<' do
+  subject { set << entry2 }
+
+  let(:set)    { DataMapper::OrderedSet.new([ entry1 ]) }
+  let(:entry1) { Object.new                             }
+
+  before do
+    @old_index = set.index(entry1)
+  end
+
+  context 'when appending a not yet included entry' do
+    let(:entry2) { Object.new }
+
+    it_should_behave_like 'DataMapper::OrderedSet#<< when appending a not yet included entry'
+  end
+
+  context 'when updating an already included entry' do
+    let(:entry2) { entry1 }
+
+    it_should_behave_like 'DataMapper::OrderedSet#<< when updating an already included entry'
+  end
+end

data/spec/unit/data_mapper/ordered_set/clear_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/clear_spec'
+
+describe 'DataMapper::OrderedSet#clear' do
+  subject { ordered_set.clear }
+
+  let(:ordered_set) { DataMapper::OrderedSet.new(entries) }
+
+  let(:entry1) { 1 }
+  let(:entry2) { 2 }
+
+  context 'when no entries are present' do
+    let(:entries) { [] }
+
+    it_should_behave_like 'DataMapper::OrderedSet#clear when no entries are present'
+  end
+
+  context 'when entries are present' do
+    let(:entries) { [ entry1, entry2 ] }
+
+    it_should_behave_like 'DataMapper::OrderedSet#clear when entries are present'
+  end
+end

data/spec/unit/data_mapper/ordered_set/delete_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/delete_spec'
+
+describe 'DataMapper::OrderedSet#delete' do
+  subject { ordered_set }
+
+  let(:ordered_set) { DataMapper::OrderedSet.new([ entry1, entry2, entry3 ]) }
+  let(:entry1)      { 1                                                      }
+  let(:entry2)      { 2                                                      }
+  let(:entry3)      { 3                                                      }
+
+  before do
+    ordered_set.delete(entry)
+  end
+
+  context 'when deleting an already included entry' do
+    let(:entry) { entry1 }
+
+    it_should_behave_like 'DataMapper::OrderedSet#delete when deleting an already included entry'
+  end
+
+  context 'when deleting a not yet included entry' do
+    let(:entry) { 4 }
+
+    it_should_behave_like 'DataMapper::OrderedSet#delete when deleting a not yet included entry'
+  end
+end