sbf-dm-core 1.3.0.beta

data/spec/public/collection_spec.rb

@@ -0,0 +1,69 @@
+require_relative '../spec_helper'
+
+# run the specs once with a loaded collection and once not
+[ false, true ].each do |loaded|
+  describe DataMapper::Collection do
+    extend DataMapper::Spec::CollectionHelpers::GroupMethods
+
+    self.loaded = loaded
+
+    before :all do
+      module ::Blog
+        class Article
+          include DataMapper::Resource
+
+          property :id,         Serial
+          property :title,      String, :required => true
+          property :content,    Text
+          property :subtitle,   String
+          property :author,     String, :required => true
+          property :attachment, Object
+
+          belongs_to :original, self, :required => false
+          has n, :revisions, self, :child_key => [ :original_id ]
+          has 1, :previous,  self, :child_key => [ :original_id ], :order => [ :id.desc ]
+          has n, :publications, :through => Resource
+        end
+
+        class Publication
+          include DataMapper::Resource
+
+          property :id,   Serial
+          property :name, String
+
+          has n, :articles, :through => Resource
+        end
+      end
+
+      DataMapper.finalize
+
+      @article_model     = Blog::Article
+      @publication_model = Blog::Publication
+    end
+
+    supported_by :all do
+      before :all do
+        @author = 'Dan Kubb'
+
+        @original = @article_model.create(:title => 'Original Article',                                               :author => @author)
+        @article  = @article_model.create(:title => 'Sample Article',   :content => 'Sample', :original => @original, :author => @author)
+        @other    = @article_model.create(:title => 'Other Article',    :content => 'Other',                          :author => @author)
+
+        # load the targets without references to a single source
+        load_collection = lambda do |query|
+          @article_model.all(query)
+        end
+
+        @articles       = load_collection.call(:title => 'Sample Article', :author => @author)
+        @other_articles = load_collection.call(:title => 'Other Article',  :author => @author)
+
+        @articles.entries if loaded
+      end
+
+      it_behaves_like 'A public Collection'
+      it_behaves_like 'A Collection supporting Strategic Eager Loading'
+      it_behaves_like 'Finder Interface'
+      it_behaves_like 'Collection Finder Interface'
+    end
+  end
+end

data/spec/public/finalize_spec.rb

@@ -0,0 +1,77 @@
+require_relative '../spec_helper'
+
+describe DataMapper do
+  describe '.finalize' do
+    subject { DataMapper.finalize }
+
+    it 'does not raise with valid models' do
+      class ::ValidObject
+        include DataMapper::Resource
+        property :id, Integer, :key => true
+      end
+      begin
+        expect(method(:subject)).not_to raise_error
+      ensure
+        DataMapper::Model.descendants.delete(ValidObject)
+        Object.send(:remove_const, :ValidObject)
+      end
+    end
+
+    it 'does not raise on valid child model' do
+      class ::ValidChild
+        include DataMapper::Resource
+        belongs_to :valid_object, :key => true
+      end
+      class ::ValidObject
+        include DataMapper::Resource
+        property :id, Integer, :key => true
+      end
+      begin
+        expect(method(:subject)).not_to raise_error
+      ensure
+        DataMapper::Model.descendants.delete(ValidChild)
+        DataMapper::Model.descendants.delete(ValidObject)
+        Object.send(:remove_const, :ValidChild)
+        Object.send(:remove_const, :ValidObject)
+      end
+    end
+
+    it 'raises on an anonymous model' do
+      model = Class.new do
+        include DataMapper::Resource
+        property :id, Integer, :key => true
+      end
+      begin
+        expect(method(:subject)).to raise_error(DataMapper::IncompleteModelError, "#{model.inspect} must have a name")
+      ensure
+        DataMapper::Model.descendants.delete(model)
+      end
+    end
+
+    it 'Raises on an empty model' do
+      class ::EmptyObject
+        include DataMapper::Resource
+      end
+      begin
+        expect(method(:subject)).to raise_error(DataMapper::IncompleteModelError,
+                                                'EmptyObject must have at least one property or many to one relationship in default to be valid')
+      ensure
+        DataMapper::Model.descendants.delete(EmptyObject)
+        Object.send(:remove_const, :EmptyObject)
+      end
+    end
+
+    it 'Raises on a keyless model' do
+      class ::KeylessObject
+        include DataMapper::Resource
+        property :name, String
+      end
+      begin
+        expect(method(:subject)).to raise_error(DataMapper::IncompleteModelError, 'KeylessObject must have a key in default to be valid')
+      ensure
+        DataMapper::Model.descendants.delete(KeylessObject)
+        Object.send(:remove_const, :KeylessObject)
+      end
+    end
+  end
+end

data/spec/public/model/hook_spec.rb

@@ -0,0 +1,245 @@
+require_relative '../../spec_helper'
+
+describe DataMapper::Model::Hook do
+  before :all do
+    class ::ModelHookSpecs
+      include DataMapper::Resource
+
+      property :id, Serial
+      property :value, Integer, :required => true, :default => 1
+
+      def an_instance_method
+      end
+    end
+
+    class ::ModelHookSpecsSubclass < ModelHookSpecs; end
+
+    DataMapper.finalize
+  end
+
+  before :all do
+    @resource = ModelHookSpecs.new
+  end
+
+  describe '#before' do
+    describe 'an instance method' do
+      before do
+        @hooks = hooks = []
+        ModelHookSpecs.before(:an_instance_method) { hooks << :before_instance_method }
+
+        @resource.an_instance_method
+      end
+
+      it 'executes before instance method hook' do
+        expect(@hooks).to eq [:before_instance_method]
+      end
+    end
+
+    describe 'save' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.before(:save) { hooks << :before_save }
+
+          @resource.save
+        end
+
+        it 'executes before save hook' do
+          expect(@hooks).to eq [:before_save]
+        end
+      end
+    end
+
+    describe 'create' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.before(:create) { hooks << :before_create }
+
+          @resource.save
+        end
+
+        it 'executes before create hook' do
+          expect(@hooks).to eq [:before_create]
+        end
+      end
+    end
+
+    describe 'update' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.before(:update) { hooks << :before_update }
+
+          @resource.save
+          @resource.update(:value => 2)
+        end
+
+        it 'executes before update hook' do
+          expect(@hooks).to eq [:before_update]
+        end
+      end
+    end
+
+    describe 'destroy' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.before(:destroy) { hooks << :before_destroy }
+
+          @resource.save
+          @resource.destroy
+        end
+
+        it 'executes before destroy hook' do
+          expect(@hooks).to eq [:before_destroy]
+        end
+      end
+    end
+
+    describe 'with an inherited hook' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.before(:an_instance_method) { hooks << :inherited_hook }
+        end
+
+        it 'executes inherited hook' do
+          ModelHookSpecsSubclass.new.an_instance_method
+          expect(@hooks).to eq [:inherited_hook]
+        end
+      end
+    end
+
+    describe 'with a hook declared in the subclasss' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecsSubclass.before(:an_instance_method) { hooks << :hook }
+        end
+
+        it 'executes hook' do
+          ModelHookSpecsSubclass.new.an_instance_method
+          expect(@hooks).to eq [:hook]
+        end
+
+        it 'does not alter hooks in the parent class' do
+          expect(@hooks).to be_empty
+          ModelHookSpecs.new.an_instance_method
+          expect(@hooks).to eq []
+        end
+      end
+    end
+  end
+
+  describe '#after' do
+    describe 'an instance method' do
+      before do
+        @hooks = hooks = []
+        ModelHookSpecs.after(:an_instance_method) { hooks << :after_instance_method }
+
+        @resource.an_instance_method
+      end
+
+      it 'executes after instance method hook' do
+        expect(@hooks).to eq [:after_instance_method]
+      end
+    end
+
+    describe 'save' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.after(:save) { hooks << :after_save }
+
+          @resource.save
+        end
+
+        it 'executes after save hook' do
+          expect(@hooks).to eq [:after_save]
+        end
+      end
+    end
+
+    describe 'create' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.after(:create) { hooks << :after_create }
+
+          @resource.save
+        end
+
+        it 'executes after create hook' do
+          expect(@hooks).to eq [:after_create]
+        end
+      end
+    end
+
+    describe 'update' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.after(:update) { hooks << :after_update }
+
+          @resource.save
+          @resource.update(:value => 2)
+        end
+
+        it 'executes after update hook' do
+          expect(@hooks).to eq [:after_update]
+        end
+      end
+    end
+
+    describe 'destroy' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.after(:destroy) { hooks << :after_destroy }
+
+          @resource.save
+          @resource.destroy
+        end
+
+        it 'executes after destroy hook' do
+          expect(@hooks).to eq [:after_destroy]
+        end
+      end
+    end
+
+    describe 'with an inherited hook' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecs.after(:an_instance_method) { hooks << :inherited_hook }
+        end
+
+        it 'executes inherited hook' do
+          ModelHookSpecsSubclass.new.an_instance_method
+          expect(@hooks).to eq [:inherited_hook]
+        end
+      end
+    end
+
+    describe 'with a hook declared in the subclasss' do
+      supported_by :all do
+        before do
+          @hooks = hooks = []
+          ModelHookSpecsSubclass.after(:an_instance_method) { hooks << :hook }
+        end
+
+        it 'executes hook' do
+          ModelHookSpecsSubclass.new.an_instance_method
+          expect(@hooks).to eq [:hook]
+        end
+
+        it 'does not alter hooks in the parent class' do
+          expect(@hooks).to be_empty
+          ModelHookSpecs.new.an_instance_method
+          expect(@hooks).to eq []
+        end
+      end
+    end
+  end
+end

data/spec/public/model/property_spec.rb

@@ -0,0 +1,91 @@
+require_relative '../../spec_helper'
+
+shared_examples 'a correct property declaration' do
+  it 'defines a name accessor' do
+    expect(@model).not_to be_method_defined(@property_name)
+    subject
+    expect(@model).to be_method_defined(@property_name)
+  end
+
+  it 'defines a name= mutator' do
+    expect(@model).not_to be_method_defined(:"#{@property_name}=")
+    subject
+    expect(@model).to be_method_defined(:"#{@property_name}=")
+  end
+end
+
+describe DataMapper::Model::Property do
+  before do
+    Object.send(:remove_const, :ModelPropertySpecs) if defined?(ModelPropertySpecs)
+    class ::ModelPropertySpecs
+      include DataMapper::Resource
+
+      property :id, Serial
+    end
+    DataMapper.finalize
+  end
+
+  describe '#property' do
+    context 'using default repository' do
+      before do
+        Object.send(:remove_const, :UserDefault) if defined?(::UserDefault)
+
+        class ::UserDefault
+          include DataMapper::Resource
+          property :id, Serial
+        end
+
+        @model         = ::UserDefault
+        @property_name = :name
+      end
+
+      subject do
+        ::UserDefault.property(:name, String)
+      end
+
+      it_behaves_like 'a correct property declaration'
+    end
+
+    context 'using alternate repository' do
+      before do
+        Object.send(:remove_const, :UserAlternate) if defined?(::UserAlternate)
+
+        class ::UserAlternate
+          include DataMapper::Resource
+          property :id, Serial
+          repository(:alternate) { property :age, Integer }
+        end
+
+        @model         = UserAlternate
+        @property_name = :alt_name
+      end
+
+      subject do
+        ::UserAlternate.property(:alt_name, String)
+      end
+
+      it_behaves_like 'a correct property declaration'
+    end
+
+    it 'raises an exception if the method exists' do
+      expect {
+        ModelPropertySpecs.property(:key, String)
+      }.to raise_error(ArgumentError,
+                           '+name+ was :key, which cannot be used as a property name since it collides with an existing method or a query option')
+    end
+
+    it 'raises an exception if the property is boolean and method with question mark already exists' do
+      expect {
+        ModelPropertySpecs.property(:destroyed, DataMapper::Property::Boolean)
+      }.to raise_error(ArgumentError,
+                           '+name+ was :destroyed, which cannot be used as a property name since it collides with an existing method or a query option')
+    end
+
+    it 'raises an exception if the name is the same as one of the query options' do
+      expect {
+        ModelPropertySpecs.property(:order, String)
+      }.to raise_error(ArgumentError,
+                           '+name+ was :order, which cannot be used as a property name since it collides with an existing method or a query option')
+    end
+  end
+end