dm-core 0.10.2 → 1.0.0.rc1

data/spec/semipublic/shared/property_shared_spec.rb

@@ -0,0 +1,143 @@
+share_examples_for 'A semipublic Property' do
+  before :all do
+    %w[ @type @name @value @other_value ].each do |ivar|
+      raise "+#{ivar}+ should be defined in before block" unless instance_variable_defined?(ivar)
+    end
+
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+        property :id, Serial
+      end
+    end
+
+    @model = Blog::Article
+    @property = @type.new(@model, @name)
+  end
+
+  describe '.new' do
+    describe 'when provided no options' do
+      it 'should return a Property' do
+        @property.should be_kind_of(@type)
+      end
+
+      it 'should set the primitive' do
+        @property.primitive.should be(@type.primitive)
+      end
+
+      it 'should set the model' do
+        @property.model.should equal(@model)
+      end
+
+      it 'should set the options to the default' do
+        @property.options.should == @type.options
+      end
+    end
+
+    [ :index, :unique_index, :unique, :lazy ].each do |attribute|
+      [ true, false, :title, [ :title ] ].each do |value|
+        describe "when provided #{(options = { attribute => value }).inspect}" do
+          before :all do
+            @property = @type.new(@model, @name, options)
+          end
+
+          it 'should return a Property' do
+            @property.should be_kind_of(@type)
+          end
+
+          it 'should set the model' do
+            @property.model.should equal(@model)
+          end
+
+          it 'should set the primitive' do
+            @property.primitive.should be(@type.primitive)
+          end
+
+          it "should set the options to #{options.inspect}" do
+            @property.options.should == @type.options.merge(options)
+          end
+        end
+      end
+
+      [ [], nil ].each do |value|
+        describe "when provided #{(invalid_options = { attribute => value }).inspect}" do
+          it 'should raise an exception' do
+            lambda {
+              @type.new(@model, @name, invalid_options)
+            }.should raise_error(ArgumentError, "options[#{attribute.inspect}] must be either true, false, a Symbol or an Array of Symbols")
+          end
+        end
+      end
+    end
+  end
+
+  describe '#load' do
+    before :all do
+      @value = mock(@value)
+    end
+
+    subject { @property.load(@value) }
+
+    describe 'with a property' do
+      it 'should delegate to #typecast' do
+        return_value = mock(@other_value)
+        @property.should_receive(:typecast).with(@value).and_return(return_value)
+        should == return_value
+      end
+    end
+  end
+
+  describe '#valid?' do
+    describe 'when provided a valid value' do
+      it 'should return true' do
+        @property.valid?(@value).should be(true)
+      end
+    end
+
+    describe 'when provide an invalid value' do
+      it 'should return false' do
+        @property.valid?(@invalid_value).should be(false)
+      end
+    end
+
+    describe 'when provide a nil value when required' do
+      it 'should return false' do
+        @property = @type.new(@model, @name, :required => true)
+        @property.valid?(nil).should be(false)
+      end
+    end
+
+    describe 'when provide a nil value when not required' do
+      it 'should return false' do
+        @property = @type.new(@model, @name, :required => false)
+        @property.valid?(nil).should be(true)
+      end
+    end
+  end
+
+  describe "#typecast" do
+    describe "when is able to do typecasting on it's own" do
+      it 'delegates all the work to the type' do
+        return_value = mock(@other_value)
+        @property.should_receive(:typecast_to_primitive).with(@invalid_value).and_return(return_value)
+        @property.typecast(@invalid_value)
+      end
+    end
+
+    describe 'when value is nil' do
+      it 'returns value unchanged' do
+        @property.typecast(nil).should be(nil)
+      end
+
+      describe 'when value is a Ruby primitive' do
+        it 'returns value unchanged' do
+          @property.typecast(@value).should == @value
+        end
+    end
+    end
+  end
+
+  describe '#value' do
+    it 'returns value for a core type'
+  end
+end

data/spec/semipublic/shared/resource_shared_spec.rb

@@ -9,19 +9,19 @@ share_examples_for 'A semipublic Resource' do
 
   describe '#attribute_dirty?' do
     describe 'on a non-dirty record' do
-      it { @user.attribute_dirty?(:age).should be_false }
+      it { @user.attribute_dirty?(:age).should be(false) }
     end
 
     describe 'on a dirty record' do
       before { @user.age = 100 }
 
-      it { @user.attribute_dirty?(:age).should be_true }
+      it { @user.attribute_dirty?(:age).should be(true) }
     end
 
     describe 'on a new record' do
       before { @user = @user_model.new }
 
-      it { @user.attribute_dirty?(:age).should be_false }
+      it { @user.attribute_dirty?(:age).should be(false) }
     end
   end
 
@@ -163,27 +163,28 @@ share_examples_for 'A semipublic Resource' do
     end
 
     with_alternate_adapter do
-      it 'should return the default adapter when nothing is specified' do
-        @user_model.create(:name => 'carl').repository.should == @repository
-        @user_model.new.repository.should                     == @repository
-        @user_model.get('carl').repository.should             == @repository
+      it 'should return the default repository when nothing is specified' do
+        default_repository = DataMapper.repository(:default)
+        @user_model.create(:name => 'carl').repository.should == default_repository
+        @user_model.new.repository.should                     == default_repository
+        @user_model.get('carl').repository.should             == default_repository
       end
 
       it 'should return the default repository for the model' do
         statistic = Statistic.create(:name => 'visits', :value => 2)
-        statistic.repository.should        == @alternate_repository
-        Statistic.new.repository.should    == @alternate_repository
-        Statistic.get(statistic.id).repository.should == @alternate_repository
+        statistic.repository.should        == @repository
+        Statistic.new.repository.should    == @repository
+        Statistic.get(statistic.id).repository.should == @repository
       end
 
       it 'should return the repository defined by the current context' do
-        @alternate_repository.scope do
-          @user_model.new.repository.should                     == @alternate_repository
-          @user_model.create(:name => 'carl').repository.should == @alternate_repository
-          @user_model.get('carl').repository.should             == @alternate_repository
+        @repository.scope do
+          @user_model.new.repository.should                     == @repository
+          @user_model.create(:name => 'carl').repository.should == @repository
+          @user_model.get('carl').repository.should             == @repository
         end
 
-        @alternate_repository.scope { @user_model.get('carl') }.repository.should == @alternate_repository
+        @repository.scope { @user_model.get('carl') }.repository.should == @repository
       end
     end
 

data/spec/semipublic/shared/resource_state_shared_spec.rb

@@ -0,0 +1,78 @@
+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::State.class_eval { alias original_set set; undef_method(:set) }
+    method(:subject).should raise_error(NoMethodError)
+    DataMapper::Resource::State.class_eval { alias 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::State.class_eval { alias original_set set; undef_method(:set) }
+    method(:subject).should_not raise_error(NoMethodError)
+    DataMapper::Resource::State.class_eval { alias 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::State::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)
+
+        @resource = @model.first(@model.key.zip(@resource.key).to_hash.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
+        should be_blank
+      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_helper.rb

@@ -1,115 +1,39 @@
 require 'pathname'
 require 'rubygems'
-
-require 'addressable/uri'
 require 'spec'
+require 'dm-core/spec/setup'
 
-SPEC_ROOT = Pathname(__FILE__).dirname.expand_path
-$LOAD_PATH.unshift(SPEC_ROOT.parent + 'lib')
-
-require 'dm-core'
-
-ENV['PLUGINS'].to_s.strip.split(/\s+/).each do |plugin|
-  require plugin
-end
-
-Pathname.glob((SPEC_ROOT + '{lib,*/shared}/**/*.rb').to_s).each { |file| require file }
-
-# create sqlite3_fs directory if it doesn't exist
-temp_db_dir = SPEC_ROOT.join('db')
-temp_db_dir.mkpath
+ENV['ADAPTER'] ||= 'in_memory'
 
-ENV['ADAPTERS'] ||= 'all'
-
-HAS_DO = DataMapper::Adapters.const_defined?('DataObjectsAdapter')
-
-ADAPTERS = []
-
-PRIMARY = {
-  'in_memory'  => { :adapter => :in_memory },
-  'yaml'       => "yaml://#{temp_db_dir}/primary_yaml",
-  'sqlite3'    => 'sqlite3::memory:',
-#  'sqlite3_fs' => "sqlite3://#{temp_db_dir}/primary.db",
-  'mysql'      => 'mysql://localhost/dm_core_test',
-  'postgres'   => 'postgres://localhost/dm_core_test',
-  'oracle'     => 'oracle://dm_core_test:dm_core_test@localhost/orcl',
-  'sqlserver'  => 'sqlserver://dm_core_test:dm_core_test@localhost/dm_core_test;instance=SQLEXPRESS'
-}
-
-ALTERNATE = {
-  'in_memory'  => { :adapter => :in_memory },
-  'yaml'       => "yaml://#{temp_db_dir}/secondary_yaml",
-  'sqlite3'    => "sqlite3://#{temp_db_dir}/alternate.db",  # use a FS for the alternate because there can only be one memory db at a time in SQLite3
-#  'sqlite3_fs' => "sqlite3://#{temp_db_dir}/alternate.db",
-  'mysql'      => 'mysql://localhost/dm_core_test2',
-  'postgres'   => 'postgres://localhost/dm_core_test2',
-  'oracle'     => 'oracle://dm_core_test2:dm_core_test2@localhost/orcl',
-  'sqlserver'  => 'sqlserver://dm_core_test:dm_core_test@localhost/dm_core_test2;instance=SQLEXPRESS'
-}
-
-# These environment variables will override the default connection string:
-#   MYSQL_SPEC_URI
-#   POSTGRES_SPEC_URI
-#   SQLITE3_SPEC_URI
-#
-# For example, in the bash shell, you might use:
-#   export MYSQL_SPEC_URI="mysql://localhost/dm_core_test?socket=/opt/local/var/run/mysql5/mysqld.sock"
+SPEC_ROOT = Pathname(__FILE__).dirname.expand_path
+LIB_ROOT  = SPEC_ROOT.parent + 'lib'
 
-adapters = ENV['ADAPTERS'].split(' ').map { |adapter_name| adapter_name.strip.downcase }.uniq
-adapters = PRIMARY.keys if adapters.include?('all')
+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 }
 
-PRIMARY.only(*adapters).each do |name, default|
-  connection_string = ENV["#{name.upcase}_SPEC_URI"] || default
-  begin
-    adapter = DataMapper.setup(name.to_sym, connection_string)
+Spec::Runner.configure do |config|
 
-    # test the connection if possible
-    if adapter.respond_to?(:query)
-      name == 'oracle' ? adapter.select('SELECT 1 FROM dual') : adapter.select('SELECT 1')
-    end
+  config.extend( DataMapper::Spec::Adapters::Helpers)
+  config.include(DataMapper::Spec::PendingHelpers)
+  config.include(DataMapper::Spec::Helpers)
 
-    ADAPTERS << name
-    PRIMARY[name] = connection_string  # ensure *_SPEC_URI is saved
-   rescue Exception => exception
-     puts "Could not connect to the database using #{connection_string.inspect} because: #{exception.inspect}"
+  config.after :all do
+    DataMapper::Spec.cleanup_models
   end
-end
 
-# speed up test execution on Oracle
-if defined?(DataMapper::Adapters::OracleAdapter)
-  DataMapper::Adapters::OracleAdapter.instance_eval do
-    auto_migrate_with :delete           # table data will be deleted instead of dropping and creating table
-    auto_migrate_reset_sequences false  # primary key sequences will not be reset
+  config.after :all do
+    # global ivar cleanup
+    DataMapper::Spec.remove_ivars(self, instance_variables.reject { |ivar| ivar[0, 2] == '@_' })
   end
-end
-
-ADAPTERS.freeze
-PRIMARY.freeze
-
-logger = DataMapper::Logger.new(DataMapper.root / 'log' / 'dm.log', :debug)
-logger.auto_flush = true
-
-Spec::Runner.configure do |config|
-  config.extend(DataMapper::Spec::AdapterHelpers)
-  config.include(DataMapper::Spec::PendingHelpers)
 
   config.after :all do
-    # global model cleanup
-    descendants = DataMapper::Model.descendants.to_a
-    while model = descendants.shift
-      descendants.concat(model.descendants.to_a - [ model ])
-
-      parts         = model.name.split('::')
-      constant_name = parts.pop.to_sym
-      base          = parts.empty? ? Object : Object.full_const_get(parts.join('::'))
-
-      if base.const_defined?(constant_name)
-        base.send(:remove_const, constant_name)
-      end
-
-      DataMapper::Model.descendants.delete(model)
-    end
+    # 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
 
 # remove the Resource#send method to ensure specs/internals do no rely on it