ardm-core 1.2.1

data/lib/dm-core/spec/shared/sel_spec.rb

@@ -0,0 +1,111 @@
+share_examples_for 'A Collection supporting Strategic Eager Loading' do
+  describe 'using SEL when looping within a loop' do
+    before :all do
+      @many_to_many = @articles.kind_of?(DataMapper::Associations::ManyToMany::Collection)
+    end
+
+    before :all do
+      attributes = {}
+
+      unless @many_to_many
+        attributes[:author] = @author
+      end
+
+      @revision = @article.revisions.create(attributes.merge(:title => 'Revision'))
+
+      @new_article  = @article_model.create(attributes.merge(:title => 'Sample Article'))
+      @new_revision = @new_article.revisions.create(attributes.merge(:title => 'New Revision'))
+    end
+
+    before :all do
+      @original_adapter = @adapter
+
+      @adapter.singleton_class.class_eval do
+        def eql?(other)
+          super || self == other
+        end
+      end
+
+      @adapter = DataMapper::Repository.adapters[@adapter.name] = CounterAdapter.new(@adapter)
+      @repository.instance_variable_set(:@adapter, @adapter)
+      @articles.instance_variable_get(:@query).instance_variable_set(:@repository, @repository)
+    end
+
+    before :all do
+      @results = []
+
+      @articles.each do |article|
+        article.revisions.each do |revision|
+          @results << [ article, revision ]
+        end
+      end
+    end
+
+    after :all do
+      @adapter = @original_adapter
+    end
+
+    it "should only execute the Adapter#read #{loaded ? 'once' : 'twice'}" do
+      @adapter.counts[:read].should == (loaded ? 1 : 2)
+    end
+
+    it 'should return the expected results' do
+      # if the collection is already loaded, then when it iterates it will
+      # not know about the newly added articles and their revisions
+      if loaded
+        @results.should == [ [ @article, @revision ] ]
+      else
+        pending_if 'TODO: make m:m not kick when delegating to the relationship', @many_to_many do
+          @results.should == [ [ @article, @revision ], [ @new_article, @new_revision ] ]
+        end
+      end
+    end
+  end
+end
+
+share_examples_for 'A Resource supporting Strategic Eager Loading' do
+  describe 'using SEL when inside a Collection' do
+    before :all do
+      @referrer = @user_model.create(:name => 'Referrer', :comment => @comment)
+
+      @user.update(:referrer => @referrer)
+
+      @new_user = @user_model.create(:name => 'Another User', :referrer => @referrer, :comment => @comment)
+    end
+
+    before :all do
+      @original_adapter = @adapter
+
+      @adapter.singleton_class.class_eval do
+        def eql?(other)
+          super || other == self
+        end
+      end
+
+      @adapter = DataMapper::Repository.adapters[@adapter.name] = CounterAdapter.new(@adapter)
+      @repository.instance_variable_set(:@adapter, @adapter)
+    end
+
+    before :all do
+      @results = @user_model.all.map do |user|
+        [ user, user.referrer ]
+      end
+
+      # some storage engines return the data in a different order
+      @results.sort!
+    end
+
+    after :all do
+      @adapter = @original_adapter
+    end
+
+    it 'should only execute the Adapter#read twice' do
+      @adapter.counts[:read].should == 2
+    end
+
+    it 'should return the expected results' do
+      # results are ordered alphabetically by the User name
+      @results.should == [ [ @new_user, @referrer ], [ @referrer, nil ], [ @user, @referrer ] ]
+    end
+  end
+end

data/lib/dm-core/spec/shared/semipublic/property_spec.rb

@@ -0,0 +1,134 @@
+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
+    @options  ||= {}
+    @property   = @type.new(@model, @name, @options)
+  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.merge(@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.merge(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.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, @options.merge(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
+    subject { @property.load(@value) }
+
+    before do
+      @property.should_receive(:typecast).with(@value).and_return(@value)
+    end
+
+    it { should eql(@value) }
+  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 '#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, @options.merge(: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, @options.merge(:required => false))
+        @property.valid?(nil).should be(true)
+      end
+    end
+  end
+end

data/lib/dm-core/spec/shared/semipublic/query/conditions/abstract_comparison_spec.rb

@@ -0,0 +1,261 @@
+shared_examples_for 'DataMapper::Query::Conditions::AbstractComparison' do
+  before :all do
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+
+        property :id,    Serial
+        property :title, String, :required => true
+
+        belongs_to :parent, self, :required => false
+        has n, :children, self, :inverse => :parent
+      end
+    end
+
+    DataMapper.finalize
+
+    @model = Blog::Article
+  end
+
+  before do
+    class ::OtherComparison < DataMapper::Query::Conditions::AbstractComparison
+      slug :other
+    end
+  end
+
+  before do
+    @relationship = @model.relationships[:parent]
+  end
+
+  it { subject.class.should respond_to(:new) }
+
+  describe '.new' do
+    subject { @comparison.class.new(@property, @value) }
+
+    it { should be_kind_of(@comparison.class) }
+
+    it { subject.subject.should equal(@property) }
+
+    it { subject.value.should == @value }
+  end
+
+  it { subject.class.should respond_to(:slug) }
+
+  describe '.slug' do
+    describe 'with no arguments' do
+      subject { @comparison.class.slug }
+
+      it { should == @slug }
+    end
+
+    describe 'with an argument' do
+      subject { @comparison.class.slug(:other) }
+
+      it { should == :other }
+
+      # reset the slug
+      after { @comparison.class.slug(@slug) }
+    end
+  end
+
+  it { should respond_to(:==) }
+
+  describe '#==' do
+    describe 'when the other AbstractComparison is equal' do
+      # artificially modify the object so #== will throw an
+      # exception if the equal? branch is not followed when heckling
+      before { @comparison.singleton_class.send(:undef_method, :slug) }
+
+      subject { @comparison == @comparison }
+
+      it { should be(true) }
+    end
+
+    describe 'when the other AbstractComparison is the same class' do
+      subject { @comparison == DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value) }
+
+      it { should be(true) }
+    end
+
+    describe 'when the other AbstractComparison is a different class' do
+      subject { @comparison == DataMapper::Query::Conditions::Comparison.new(:other, @property, @value) }
+
+      it { should be(false) }
+    end
+
+    describe 'when the other AbstractComparison is the same class, with different property' do
+      subject { @comparison == DataMapper::Query::Conditions::Comparison.new(@slug, @other_property, @value) }
+
+      it { should be(false) }
+    end
+
+    describe 'when the other AbstractComparison is the same class, with different value' do
+      subject { @comparison == DataMapper::Query::Conditions::Comparison.new(@slug, @property, @other_value) }
+
+      it { should be(false) }
+    end
+  end
+
+  it { should respond_to(:eql?) }
+
+  describe '#eql?' do
+    describe 'when the other AbstractComparison is equal' do
+      # artificially modify the object so #eql? will throw an
+      # exception if the equal? branch is not followed when heckling
+      before { @comparison.singleton_class.send(:undef_method, :slug) }
+
+      subject { @comparison.eql?(@comparison) }
+
+      it { should be(true) }
+    end
+
+    describe 'when the other AbstractComparison is the same class' do
+      subject { @comparison.eql?(DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)) }
+
+      it { should be(true) }
+    end
+
+    describe 'when the other AbstractComparison is a different class' do
+      subject { @comparison.eql?(DataMapper::Query::Conditions::Comparison.new(:other, @property, @value)) }
+
+      it { should be(false) }
+    end
+
+    describe 'when the other AbstractComparison is the same class, with different property' do
+      subject { @comparison.eql?(DataMapper::Query::Conditions::Comparison.new(@slug, @other_property, @value)) }
+
+      it { should be(false) }
+    end
+
+    describe 'when the other AbstractComparison is the same class, with different value' do
+      subject { @comparison.eql?(DataMapper::Query::Conditions::Comparison.new(@slug, @property, @other_value)) }
+
+      it { should be(false) }
+    end
+  end
+
+  it { should respond_to(:hash) }
+
+  describe '#hash' do
+    subject { @comparison.hash }
+
+    it 'should match the same AbstractComparison with the same property and value' do
+      should == DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value).hash
+    end
+
+    it 'should not match the same AbstractComparison with different property' do
+      should_not == DataMapper::Query::Conditions::Comparison.new(@slug, @other_property, @value).hash
+    end
+
+    it 'should not match the same AbstractComparison with different value' do
+      should_not == DataMapper::Query::Conditions::Comparison.new(@slug, @property, @other_value).hash
+    end
+
+    it 'should not match a different AbstractComparison with the same property and value' do
+      should_not == @other.hash
+    end
+
+    it 'should not match a different AbstractComparison with different property' do
+      should_not == @other.class.new(@other_property, @value).hash
+    end
+
+    it 'should not match a different AbstractComparison with different value' do
+      should_not == @other.class.new(@property, @other_value).hash
+    end
+  end
+
+  it { should respond_to(:loaded_value) }
+
+  describe '#loaded_value' do
+    subject { @comparison.loaded_value }
+
+    it { should == @value }
+  end
+
+  it { should respond_to(:parent) }
+
+  describe '#parent' do
+    subject { @comparison.parent }
+
+    describe 'should be nil by default' do
+      it { should be_nil }
+    end
+
+    describe 'should relate to parent operation' do
+      before do
+        @operation = DataMapper::Query::Conditions::Operation.new(:and)
+        @comparison.parent = @operation
+      end
+
+      it { should be_equal(@operation) }
+    end
+  end
+
+  it { should respond_to(:parent=) }
+
+  describe '#parent=' do
+    before do
+      @operation = DataMapper::Query::Conditions::Operation.new(:and)
+    end
+
+    subject { @comparison.parent = @operation }
+
+    it { should equal(@operation) }
+
+    it 'should change the parent' do
+      method(:subject).should change(@comparison, :parent).
+        from(nil).
+        to(@operation)
+    end
+  end
+
+  it { should respond_to(:property?) }
+
+  describe '#property?' do
+    subject { @comparison.property? }
+
+    it { should be(true) }
+  end
+
+  it { should respond_to(:slug) }
+
+  describe '#slug' do
+    subject { @comparison.slug }
+
+    it { should == @slug }
+  end
+
+  it { should respond_to(:subject) }
+
+  describe '#subject' do
+    subject { @comparison.subject }
+
+    it { should be_equal(@property) }
+  end
+
+  it { should respond_to(:valid?) }
+
+  describe '#valid?' do
+    subject { @comparison.valid? }
+
+    describe 'when the value is valid for the subject' do
+      it { should be(true) }
+    end
+
+    describe 'when the value is not valid for the subject' do
+      before do
+        @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, nil)
+      end
+
+      it { should be(false) }
+    end
+  end
+
+  it { should respond_to(:value) }
+
+  describe '#value' do
+    subject { @comparison.value }
+
+    it { should == @value }
+  end
+end