dm-core 0.10.1 → 0.10.2

data/spec/public/transaction_spec.rb

@@ -12,7 +12,10 @@ describe DataMapper::Resource, 'Transactions' do
         property :description, Text
         property :admin,       Boolean, :accessor => :private
 
-        belongs_to :referrer, self, :nullable => true
+        belongs_to :parent, self, :required => false
+        has n, :children, self, :inverse => :parent
+
+        belongs_to :referrer, self, :required => false
         has n, :comments
 
         # FIXME: figure out a different approach than stubbing things out
@@ -51,6 +54,12 @@ describe DataMapper::Resource, 'Transactions' do
       end
     end
 
+    class ::Default
+      include DataMapper::Resource
+
+      property :name, String, :key => true, :default => 'a default value'
+    end
+
     @user_model      = Blog::User
     @author_model    = Blog::Author
     @comment_model   = Blog::Comment
@@ -58,7 +67,7 @@ describe DataMapper::Resource, 'Transactions' do
     @paragraph_model = Blog::Paragraph
   end
 
-  supported_by :postgres, :mysql, :sqlite3, :oracle do
+  supported_by :postgres, :mysql, :sqlite3, :oracle, :sqlserver do
     before :all do
       user = @user_model.create(:name => 'dbussink', :age => 25, :description => 'Test')
 
@@ -84,7 +93,7 @@ describe DataMapper::Resource, 'Transactions' do
     it_should_behave_like 'A Resource supporting Strategic Eager Loading'
   end
 
-  supported_by :postgres, :mysql, :sqlite3, :oracle do
+  supported_by :postgres, :mysql, :sqlite3, :oracle, :sqlserver do
     describe '#transaction' do
       before do
         @user_model.all.destroy!
@@ -121,6 +130,21 @@ describe DataMapper::Resource, 'Transactions' do
         @user_model.all.should have(0).entries
       end
 
+      it 'should close the transaction if return is called within the closure' do
+        @txn = nil
+
+        def doit
+          @user_model.transaction do
+            @txn = Thread.current[:dm_transactions].last
+            return
+          end
+        end
+        doit
+
+        @txn.instance_variable_get(:@state).should == :commit
+        @txn = nil
+      end
+
       it 'should return the last statement in the transaction block' do
         @user_model.transaction { 1 }.should == 1
       end

data/spec/public/types/discriminator_spec.rb

@@ -7,7 +7,7 @@ describe DataMapper::Types::Discriminator do
         include DataMapper::Resource
 
         property :id,    Serial
-        property :title, String, :nullable => false
+        property :title, String, :required => true
         property :type,  Discriminator
       end
 

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude "spec"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/semipublic/adapters/sqlserver_adapter_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+dir = DataMapper.root / 'lib' / 'dm-core' / 'spec'
+
+require dir / 'adapter_shared_spec'
+require dir / 'data_objects_adapter_shared_spec'
+
+describe 'Adapter' do
+  supported_by :sqlserver do
+    describe DataMapper::Adapters::SqlserverAdapter do
+
+      it_should_behave_like 'An Adapter'
+      it_should_behave_like 'A DataObjects Adapter'
+
+    end
+  end
+end

data/spec/semipublic/associations/many_to_one_spec.rb

@@ -12,40 +12,23 @@ describe 'Many to One Associations' do
       has n, :comments
     end
 
-    # This is a special class that needs to be an exact copy of User
-    class ::Clone
-      include DataMapper::Resource
-
-      property :name,        String, :key => true
-      property :age,         Integer
-      property :description, Text
-    end
-
     class ::Comment
       include DataMapper::Resource
 
-      property :id,   Serial
-      property :body, Text
+      property :id, Serial
 
       belongs_to :user
     end
 
-    class ::Default
-      include DataMapper::Resource
-
-      property :name, String, :key => true, :default => 'a default value'
-    end
-
     @user_model    = User
     @comment_model = Comment
   end
 
   supported_by :all do
     before :all do
-      comment = @comment_model.create(:body => 'Cool spec', :user => User.create(:name => 'dbussink', :age => 25, :description => 'Test'))
+      comment = @comment_model.create(:user => User.create(:name => 'dbussink', :age => 25, :description => 'Test'))
 
-      comment = @comment_model.get(*comment.key)
-      @user   = comment.user
+      @user = @comment_model.get(*comment.key).user
     end
 
     it_should_behave_like 'A semipublic Resource'

data/spec/semipublic/associations_spec.rb

@@ -170,8 +170,8 @@ describe DataMapper::Associations do
       @relationship.max.should == 1
     end
 
-    it 'should return a Relationship that is not nullable' do
-      @relationship.nullable?.should be_false
+    it 'should return a Relationship that is required' do
+      @relationship.required?.should be_true
     end
   end
 end

data/spec/semipublic/collection_spec.rb

@@ -74,22 +74,6 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
         end
       end
 
-      it { @articles.should respond_to(:properties) }
-
-      describe '#properties' do
-        before :all do
-          @return = @properties = @articles.properties
-        end
-
-        it 'should return a PropertySet' do
-          @return.should be_kind_of(DataMapper::PropertySet)
-        end
-
-        it 'should be expected properties' do
-          @properties.to_a.should == @articles_query.fields
-        end
-      end
-
       it { @articles.should respond_to(:query) }
 
       describe '#query' do
@@ -106,22 +90,6 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
         end
       end
 
-      it { @articles.should respond_to(:relationships) }
-
-      describe '#relationships' do
-        before :all do
-          @return = @relationships = @articles.relationships
-        end
-
-        it 'should return a Hash' do
-          @return.should be_kind_of(Hash)
-        end
-
-        it 'should return expected Hash' do
-          @return.should equal(@article_model.relationships(@article_repository.name))
-        end
-      end
-
       it { @articles.should respond_to(:repository) }
 
       describe '#repository' do

data/spec/semipublic/model_spec.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe DataMapper::Model do
+
+  it { should respond_to(:append_inclusions) }
+
+  describe '.append_inclusions' do
+    module ::Inclusions
+      def new_method
+      end
+    end
+
+    describe 'before the model is defined' do
+      before :all do
+        DataMapper::Model.append_inclusions(Inclusions)
+
+        class ::User
+          include DataMapper::Resource
+          property :id, Serial
+        end
+      end
+
+      it 'should respond to :new_method' do
+        User.new.should respond_to(:new_method)
+      end
+
+      after :all do
+        DataMapper::Model.extra_inclusions.delete(Inclusions)
+      end
+    end
+
+    describe 'after the model is defined' do
+      before :all do
+        class ::User
+          include DataMapper::Resource
+          property :id, Serial
+        end
+        DataMapper::Model.append_inclusions(Inclusions)
+      end
+
+      it 'should respond to :new_method' do
+        User.new.should respond_to(:new_method)
+      end
+
+      after :all do
+        DataMapper::Model.extra_inclusions.delete(Inclusions)
+      end
+    end
+  end
+
+  it { should respond_to(:append_extensions) }
+
+  describe '.append_extensions' do
+    module ::Extensions
+      def new_method
+      end
+    end
+
+    describe 'before the model is defined' do
+      before :all do
+        DataMapper::Model.append_extensions(Extensions)
+
+        class ::User
+          include DataMapper::Resource
+          property :id, Serial
+        end
+      end
+
+      it 'should respond to :new_method' do
+        User.should respond_to(:new_method)
+      end
+
+      after :all do
+        DataMapper::Model.extra_extensions.delete(Extensions)
+      end
+    end
+
+    describe 'after the model is defined' do
+      before :all do
+        class ::User
+          include DataMapper::Resource
+          property :id, Serial
+        end
+        DataMapper::Model.append_extensions(Extensions)
+      end
+
+      it 'should respond to :new_method' do
+        User.should respond_to(:new_method)
+      end
+
+      after :all do
+        DataMapper::Model.extra_extensions.delete(Extensions)
+      end
+    end
+  end
+end

data/spec/semipublic/property_spec.rb

@@ -455,7 +455,7 @@ describe DataMapper::Property do
       end
 
       it 'does not typecast non-time values' do
-        pending 'Time#parse is too permissive' do
+        pending_if 'Time#parse is too permissive', RUBY_VERSION <= '1.9.1' do
           @property.typecast('not-time').should eql('not-time')
         end
       end
@@ -517,13 +517,13 @@ describe DataMapper::Property do
       end
     end
 
-    describe 'when provide a nil value when not nullable' do
+    describe 'when provide a nil value when required' do
       it 'should return false' do
         @model.properties[:id].valid?(nil).should be_false
       end
     end
 
-    describe 'when provide a nil value when nullable' do
+    describe 'when provide a nil value when not required' do
       it 'should return false' do
         @model.properties[:alias].valid?(nil).should be_true
       end

data/spec/semipublic/query/conditions/comparison_spec.rb

@@ -0,0 +1,1719 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper'))
+
+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
+
+    @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
+      # artifically modify the object so #== will throw an
+      # exception if the equal? branch is not followed when heckling
+      before { @comparison.meta_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
+      # artifically modify the object so #eql? will throw an
+      # exception if the equal? branch is not followed when heckling
+      before { @comparison.meta_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
+
+describe DataMapper::Query::Conditions::Comparison do
+  before :all do
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+
+        property :id,    Serial
+        property :title, String, :required => true
+      end
+    end
+
+    @model = Blog::Article
+  end
+
+  before :all do
+    @property = @model.properties[:id]
+  end
+
+  it { DataMapper::Query::Conditions::Comparison.should respond_to(:new) }
+
+  describe '.new' do
+    {
+      :eql    => DataMapper::Query::Conditions::EqualToComparison,
+      :in     => DataMapper::Query::Conditions::InclusionComparison,
+      :regexp => DataMapper::Query::Conditions::RegexpComparison,
+      :like   => DataMapper::Query::Conditions::LikeComparison,
+      :gt     => DataMapper::Query::Conditions::GreaterThanComparison,
+      :lt     => DataMapper::Query::Conditions::LessThanComparison,
+      :gte    => DataMapper::Query::Conditions::GreaterThanOrEqualToComparison,
+      :lte    => DataMapper::Query::Conditions::LessThanOrEqualToComparison,
+    }.each do |slug, klass|
+      describe "with a slug #{slug.inspect}" do
+        subject { DataMapper::Query::Conditions::Comparison.new(slug, @property, @value) }
+
+        it { should be_kind_of(klass) }
+      end
+    end
+
+    describe 'with an invalid slug' do
+      subject { DataMapper::Query::Conditions::Comparison.new(:invalid, @property, @value) }
+
+      it { method(:subject).should raise_error(ArgumentError, 'No Comparison class for :invalid has been defined') }
+    end
+  end
+end
+
+describe DataMapper::Query::Conditions::EqualToComparison do
+  it_should_behave_like 'DataMapper::Query::Conditions::AbstractComparison'
+
+  before do
+    @property       = @model.properties[:id]
+    @other_property = @model.properties[:title]
+    @value          = 1
+    @other_value    = 2
+    @slug           = :eql
+    @comparison     = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+    @other          = OtherComparison.new(@property, @value)
+  end
+
+  subject { @comparison }
+
+  it { should respond_to(:foreign_key_mapping) }
+
+  describe '#foreign_key_mapping' do
+    supported_by :all do
+      before do
+        @parent = @model.create(:title => 'Parent')
+        @child  = @parent.children.create(:title => 'Child')
+
+        @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @parent)
+      end
+
+      it 'should return criteria that matches the record' do
+        @model.all(:conditions => @comparison.foreign_key_mapping).should == [ @child ]
+      end
+    end
+  end
+
+  it { should respond_to(:inspect) }
+
+  describe '#inspect' do
+    subject { @comparison.inspect }
+
+    it { should == '#<DataMapper::Query::Conditions::EqualToComparison @subject=#<DataMapper::Property @model=Blog::Article @name=:id> @dumped_value=1 @loaded_value=1>' }
+  end
+
+  it { should respond_to(:matches?) }
+
+  describe '#matches?' do
+    supported_by :all do
+      describe 'with a Property subject' do
+        describe 'with an Integer value' do
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?(@property.field => 1) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?(@property.field => 2) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => 1)) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => 2)) }
+
+            it { should be_false }
+          end
+        end
+
+        describe 'with a nil value' do
+          before do
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, nil)
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?(@property.field => nil) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?(@property.field => 1) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => nil)) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => 1)) }
+
+            it { should be_false }
+          end
+        end
+      end
+
+      describe 'with a Relationship subject' do
+        describe 'with a Relationship subject and a nil value' do
+          before do
+            @parent = @model.create(:title => 'Parent')
+            @child  = @parent.children.create(:title => 'Child')
+
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, nil)
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => nil }) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => {} }) }
+
+            it { pending { should be_false } }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@parent) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@child) }
+
+            it { should be_false }
+          end
+        end
+
+        describe 'with a Relationship subject and a Hash value' do
+          before do
+            @parent = @model.create(:title => 'Parent')
+            @child  = @parent.children.create(:title => 'Child')
+
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @parent.attributes.except(:id))
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @parent.attributes(:field) }) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @child.attributes(:field) }) }
+
+            it { pending { should be_false } }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@child) }
+
+            it { pending { should be_true } }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@parent) }
+
+            it { pending { should be_false } }
+          end
+        end
+
+        describe 'with a Relationship subject and new Resource value' do
+          before do
+            @parent = @model.create(:title => 'Parent')
+            @child  = @parent.children.create(:title => 'Child')
+
+            new_resource = @model.new(@parent.attributes.except(:id))
+
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, new_resource)
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @parent.attributes(:field) }) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @child.attributes(:field) }) }
+
+            it { pending { should be_false } }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@child) }
+
+            it { pending { should be_true } }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@parent) }
+
+            it { pending { should be_false } }
+          end
+        end
+
+        describe 'with a Relationship subject and saved Resource value' do
+          before do
+            @parent = @model.create(:title => 'Parent')
+            @child  = @parent.children.create(:title => 'Child')
+
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @parent)
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @parent.attributes(:field) }) }
+
+            it { pending { should be_true } }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @child.attributes(:field) }) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@child) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@parent) }
+
+            it { should be_false }
+          end
+        end
+      end
+    end
+  end
+
+  it { should respond_to(:relationship?) }
+
+  describe '#relationship?' do
+    subject { @comparison.relationship? }
+
+    it { should be_false }
+  end
+
+  it { should respond_to(:to_s) }
+
+  describe '#to_s' do
+    subject { @comparison.to_s }
+
+    it { should == 'id = 1' }
+  end
+
+  it { should respond_to(:value) }
+
+  describe '#value' do
+    supported_by :all do
+      subject { @comparison.value }
+
+      describe 'with a Property subject' do
+        describe 'with an Integer value' do
+          it { should == @value }
+        end
+
+        describe 'with a nil value' do
+          before do
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, nil)
+          end
+
+          it { should be_nil }
+        end
+      end
+
+      describe 'with a Relationship subject' do
+        before :all do
+          @parent = @model.create(:title => 'Parent')
+          @child  = @parent.children.create(:title => 'Child')
+        end
+
+        describe 'with an Hash value' do
+          before do
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, :id => 1)
+          end
+
+          it { should == @model.new(:id => 1) }
+        end
+
+        describe 'with a Resource value' do
+          before do
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @parent)
+          end
+
+          it { should == @parent }
+        end
+      end
+    end
+  end
+end
+
+describe DataMapper::Query::Conditions::InclusionComparison do
+  it_should_behave_like 'DataMapper::Query::Conditions::AbstractComparison'
+
+  before do
+    @property       = @model.properties[:id]
+    @other_property = @model.properties[:title]
+    @value          = [ 1 ]
+    @other_value    = [ 2 ]
+    @slug           = :in
+    @comparison     = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+    @other          = OtherComparison.new(@property, @value)
+  end
+
+  subject { @comparison }
+
+  it { should respond_to(:foreign_key_mapping) }
+
+  describe '#foreign_key_mapping' do
+    supported_by :all do
+      before do
+        @parent = @model.create(:title => 'Parent')
+        @child  = @parent.children.create(:title => 'Child')
+
+        @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @model.all)
+      end
+
+      it 'should return criteria that matches the record' do
+        @model.all(:conditions => @comparison.foreign_key_mapping).should == [ @child ]
+      end
+    end
+  end
+
+  it { should respond_to(:inspect) }
+
+  describe '#inspect' do
+    subject { @comparison.inspect }
+
+    it { should == '#<DataMapper::Query::Conditions::InclusionComparison @subject=#<DataMapper::Property @model=Blog::Article @name=:id> @dumped_value=[1] @loaded_value=[1]>' }
+  end
+
+  it { should respond_to(:matches?) }
+
+  describe '#matches?' do
+    supported_by :all do
+      describe 'with a Property subject' do
+        describe 'with an Array value' do
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?(@property.field => 1) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?(@property.field => 2) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => 1)) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => 2)) }
+
+            it { should be_false }
+          end
+        end
+
+        describe 'with an Array value that needs typecasting' do
+          before do
+            @value      = [ '1' ]
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?(@property.field => 1) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?(@property.field => 2) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => 1)) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => 2)) }
+
+            it { should be_false }
+          end
+        end
+
+        describe 'with a Range value' do
+          before do
+            @value      = 1..2
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?(@property.field => 1) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?(@property.field => 0) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => 1)) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => 0)) }
+
+            it { should be_false }
+          end
+        end
+
+        describe 'with a Range value that needs typecasting' do
+          before do
+            @value      = '1'...'2'
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?(@property.field => 1) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?(@property.field => 2) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => 1)) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@model.new(@property => 2)) }
+
+            it { should be_false }
+          end
+        end
+      end
+
+      describe 'with a Relationship subject' do
+        describe 'with a Hash value' do
+          before do
+            @parent = @model.create(:title => 'Parent')
+            @child  = @parent.children.create(:title => 'Child')
+
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @parent.attributes.except(:id))
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @parent.attributes(:field) }) }
+
+            it { pending { should be_true } }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @child.attributes(:field) }) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@child) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@parent) }
+
+            it { should be_false }
+          end
+        end
+
+        describe 'with a new Resource value' do
+          before do
+            @parent = @model.create(:title => 'Parent')
+            @child  = @parent.children.create(:title => 'Child')
+
+            new_resource = @model.new(@parent.attributes.except(:id))
+
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, new_resource)
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @parent.attributes(:field) }) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @child.attributes(:field) }) }
+
+            it { pending { should be_false } }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@child) }
+
+            it { pending { should be_true } }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@parent) }
+
+            it { pending { should be_false } }
+          end
+        end
+
+        describe 'with a saved Resource value' do
+          before do
+            @parent = @model.create(:title => 'Parent')
+            @child  = @parent.children.create(:title => 'Child')
+
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @parent)
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @parent.attributes(:field) }) }
+
+            it { pending { should be_true } }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @child.attributes(:field) }) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@child) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@parent) }
+
+            it { should be_false }
+          end
+        end
+
+        describe 'with a Collection value' do
+          before do
+            @parent = @model.create(:title => 'Parent')
+            @child  = @parent.children.create(:title => 'Child')
+
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @model.all(:title => 'Parent'))
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @parent.attributes(:field) }) }
+
+            it { pending { should be_true } }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @child.attributes(:field) }) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@child) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@parent) }
+
+            it { should be_false }
+          end
+        end
+
+        describe 'with an Enumerable value containing a Hash' do
+          before do
+            @parent = @model.create(:title => 'Parent')
+            @child  = @parent.children.create(:title => 'Child')
+
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, [ @parent.attributes.except(:id), { :title => 'Other' } ])
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @parent.attributes(:field) }) }
+
+            it { pending { should be_true } }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @child.attributes(:field) }) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@child) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@parent) }
+
+            it { should be_false }
+          end
+        end
+
+        describe 'with an Enumerable value containing a new Resource' do
+          before do
+            @parent = @model.create(:title => 'Parent')
+            @child  = @parent.children.create(:title => 'Child')
+
+            new_resource = @model.new(@parent.attributes.except(:id))
+
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, [ new_resource ])
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @parent.attributes(:field) }) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @child.attributes(:field) }) }
+
+            it { pending { should be_false } }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@child) }
+
+            it { pending { should be_true } }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@parent) }
+
+            it { pending { should be_false } }
+          end
+        end
+
+        describe 'with an Enumerable value containing a saved Resource' do
+          before do
+            @parent = @model.create(:title => 'Parent')
+            @child  = @parent.children.create(:title => 'Child')
+
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, [ @parent ])
+          end
+
+          describe 'with a matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @parent.attributes(:field) }) }
+
+            it { pending { should be_true } }
+          end
+
+          describe 'with a not matching Hash' do
+            subject { @comparison.matches?({ @relationship.field => @child.attributes(:field) }) }
+
+            it { should be_false }
+          end
+
+          describe 'with a matching Resource' do
+            subject { @comparison.matches?(@child) }
+
+            it { should be_true }
+          end
+
+          describe 'with a not matching Resource' do
+            subject { @comparison.matches?(@parent) }
+
+            it { should be_false }
+          end
+        end
+      end
+    end
+  end
+
+  it { should respond_to(:relationship?) }
+
+  describe '#relationship?' do
+    subject { @comparison.relationship? }
+
+    it { should be_false }
+  end
+
+  it { should respond_to(:to_s) }
+
+  describe '#to_s' do
+    subject { @comparison.to_s }
+
+    it { should == 'id IN [1]' }
+  end
+
+  it { should respond_to(:valid?) }
+
+  describe '#valid?' do
+    subject { @comparison.valid? }
+
+    describe 'with a Property subject' do
+      describe 'with a valid Array value' do
+        it { should be_true }
+      end
+
+      describe 'with a valid Array value that needs typecasting' do
+        before do
+          @value      = [ '1' ]
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+        end
+
+        it { should be_true }
+      end
+
+      describe 'with an invalid Array value' do
+        before do
+          @value      = [ 'invalid' ]
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+        end
+
+        it { should be_false }
+      end
+
+      describe 'with an empty Array value' do
+        before do
+          @value      = []
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+        end
+
+        it { should be_false }
+      end
+
+      describe 'with a valid Range value' do
+        before do
+          @value      = 1..1
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+        end
+
+        it { should be_true }
+      end
+
+      describe 'with a valid Range value that needs typecasting' do
+        before do
+          @value      = '1'...'2'
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+        end
+
+        it { should be_true }
+      end
+
+      describe 'with an invalid Range value' do
+        before do
+          @value      = 'a'..'z'
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+        end
+
+        it { should be_false }
+      end
+
+      describe 'with an empty Range value' do
+        before do
+          @value      = 1..0
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+        end
+
+        it { should be_false }
+      end
+    end
+
+    describe 'with a Relationship subject' do
+      describe 'with a valid Array value' do
+        before do
+          @value      = [ @model.new(:id => 1) ]
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @value)
+        end
+
+        it { should be_true }
+      end
+
+      describe 'with an invalid Array value' do
+        before do
+          @value      = [ @model.new ]
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @value)
+        end
+
+        it { should be_false }
+      end
+
+      describe 'with an empty Array value' do
+        before do
+          @value      = []
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @value)
+        end
+
+        it { should be_false }
+      end
+
+      describe 'with a valid Collection' do
+        before do
+          @value      = @model.all
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @value)
+        end
+
+        it { should be_true }
+      end
+    end
+  end
+
+  it { should respond_to(:value) }
+
+  describe '#value' do
+    supported_by :all do
+      subject { @comparison.value }
+
+      describe 'with a Property subject' do
+        describe 'with an Array value' do
+          before do
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, [ 1, 1 ])
+          end
+
+          it { should be_kind_of(Array) }
+
+          it { should == @value }
+        end
+
+        describe 'with a Range value' do
+          before do
+            @value      = 1..1
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+          end
+
+          it { should be_kind_of(Range) }
+
+          it { should == @value }
+        end
+      end
+
+      describe 'with a Relationship subject' do
+        before :all do
+          @parent = @model.create(:title => 'Parent')
+          @child  = @parent.children.create(:title => 'Child')
+        end
+
+        describe 'with an Hash value' do
+          before do
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, :id => @parent.id)
+          end
+
+          it { should be_kind_of(DataMapper::Collection) }
+
+          it { should == [ @parent ] }
+        end
+
+        describe 'with an Array value' do
+          before do
+            @value      = [ @parent ]
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @value)
+          end
+
+          it { should be_kind_of(DataMapper::Collection) }
+
+          it { should == @value }
+        end
+
+        describe 'with a Resource value' do
+          before do
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @parent)
+          end
+
+          it { should be_kind_of(DataMapper::Collection) }
+
+          it { should == [ @parent ] }
+        end
+
+        describe 'with a Collection value' do
+          before do
+            @value      = @model.all
+            @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @relationship, @value)
+          end
+
+          it 'should not be a kicker' do
+            @value.should_not be_loaded
+          end
+
+          it { should be_kind_of(DataMapper::Collection) }
+
+          it { should == @value }
+        end
+      end
+    end
+  end
+end
+
+describe DataMapper::Query::Conditions::RegexpComparison do
+  it_should_behave_like 'DataMapper::Query::Conditions::AbstractComparison'
+
+  before do
+    @property       = @model.properties[:title]
+    @other_property = @model.properties[:id]
+    @value       = /Title/
+    @other_value = /Other Title/
+    @slug        = :regexp
+    @comparison  = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+    @other       = OtherComparison.new(@property, @value)
+  end
+
+  subject { @comparison }
+
+  it { should respond_to(:inspect) }
+
+  describe '#inspect' do
+    subject { @comparison.inspect }
+
+    it { should == '#<DataMapper::Query::Conditions::RegexpComparison @subject=#<DataMapper::Property @model=Blog::Article @name=:title> @dumped_value=/Title/ @loaded_value=/Title/>' }
+  end
+
+  it { should respond_to(:matches?) }
+
+  describe '#matches?' do
+    supported_by :all do
+      describe 'with a matching Hash' do
+        subject { @comparison.matches?(@property.field => 'Title') }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Hash' do
+        subject { @comparison.matches?(@property.field => 'Other') }
+
+        it { should be_false }
+      end
+
+      describe 'with a matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 'Title')) }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 'Other')) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil field' do
+        subject { @comparison.matches?(@property.field => nil) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil attribute' do
+        subject { @comparison.matches?(@model.new(@property => nil)) }
+
+        it { should be_false }
+      end
+    end
+  end
+
+  it { should respond_to(:relationship?) }
+
+  describe '#relationship?' do
+    subject { @comparison.relationship? }
+
+    it { should be_false }
+  end
+
+  it { should respond_to(:to_s) }
+
+  describe '#to_s' do
+    subject { @comparison.to_s }
+
+    it { should == 'title =~ /Title/' }
+  end
+end
+
+describe DataMapper::Query::Conditions::LikeComparison do
+  it_should_behave_like 'DataMapper::Query::Conditions::AbstractComparison'
+
+  before do
+    @property       = @model.properties[:title]
+    @other_property = @model.properties[:id]
+    @value          = '_it%'
+    @other_value    = 'Other Title'
+    @slug           = :like
+    @comparison     = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+    @other          = OtherComparison.new(@property, @value)
+  end
+
+  subject { @comparison }
+
+  it { should respond_to(:inspect) }
+
+  describe '#inspect' do
+    subject { @comparison.inspect }
+
+    it { should == '#<DataMapper::Query::Conditions::LikeComparison @subject=#<DataMapper::Property @model=Blog::Article @name=:title> @dumped_value="_it%" @loaded_value="_it%">' }
+  end
+
+  it { should respond_to(:matches?) }
+
+  describe '#matches?' do
+    supported_by :all do
+      describe 'with a matching Hash' do
+        subject { @comparison.matches?(@property.field => 'Title') }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Hash' do
+        subject { @comparison.matches?(@property.field => 'Other Title') }
+
+        it { should be_false }
+      end
+
+      describe 'with a matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 'Title')) }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 'Other Title')) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil field' do
+        subject { @comparison.matches?(@property.field => nil) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil attribute' do
+        subject { @comparison.matches?(@model.new(@property => nil)) }
+
+        it { should be_false }
+      end
+    end
+  end
+
+  it { should respond_to(:relationship?) }
+
+  describe '#relationship?' do
+    subject { @comparison.relationship? }
+
+    it { should be_false }
+  end
+
+  it { should respond_to(:to_s) }
+
+  describe '#to_s' do
+    subject { @comparison.to_s }
+
+    it { should == 'title LIKE "_it%"' }
+  end
+end
+
+describe DataMapper::Query::Conditions::GreaterThanComparison do
+  it_should_behave_like 'DataMapper::Query::Conditions::AbstractComparison'
+
+  before do
+    @property       = @model.properties[:id]
+    @other_property = @model.properties[:title]
+    @value          = 1
+    @other_value    = 2
+    @slug           = :gt
+    @comparison     = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+    @other          = OtherComparison.new(@property, @value)
+  end
+
+  subject { @comparison }
+
+  it { should respond_to(:inspect) }
+
+  describe '#inspect' do
+    subject { @comparison.inspect }
+
+    it { should == '#<DataMapper::Query::Conditions::GreaterThanComparison @subject=#<DataMapper::Property @model=Blog::Article @name=:id> @dumped_value=1 @loaded_value=1>' }
+  end
+
+  it { should respond_to(:matches?) }
+
+  describe '#matches?' do
+    supported_by :all do
+      describe 'with a matching Hash' do
+        subject { @comparison.matches?(@property.field => 2) }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Hash' do
+        subject { @comparison.matches?(@property.field => 1) }
+
+        it { should be_false }
+      end
+
+      describe 'with a matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 2)) }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 1)) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil field' do
+        subject { @comparison.matches?(@property.field => nil) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil attribute' do
+        subject { @comparison.matches?(@model.new(@property => nil)) }
+
+        it { should be_false }
+      end
+    end
+  end
+
+  it { should respond_to(:relationship?) }
+
+  describe '#relationship?' do
+    subject { @comparison.relationship? }
+
+    it { should be_false }
+  end
+
+  it { should respond_to(:to_s) }
+
+  describe '#to_s' do
+    subject { @comparison.to_s }
+
+    it { should == 'id > 1' }
+  end
+end
+
+describe DataMapper::Query::Conditions::LessThanComparison do
+  it_should_behave_like 'DataMapper::Query::Conditions::AbstractComparison'
+
+  before do
+    @property       = @model.properties[:id]
+    @other_property = @model.properties[:title]
+    @value          = 1
+    @other_value    = 2
+    @slug           = :lt
+    @comparison     = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+    @other          = OtherComparison.new(@property, @value)
+  end
+
+  subject { @comparison }
+
+  it { should respond_to(:inspect) }
+
+  describe '#inspect' do
+    subject { @comparison.inspect }
+
+    it { should == '#<DataMapper::Query::Conditions::LessThanComparison @subject=#<DataMapper::Property @model=Blog::Article @name=:id> @dumped_value=1 @loaded_value=1>' }
+  end
+
+  it { should respond_to(:matches?) }
+
+  describe '#matches?' do
+    supported_by :all do
+      describe 'with a matching Hash' do
+        subject { @comparison.matches?(@property.field => 0) }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Hash' do
+        subject { @comparison.matches?(@property.field => 1) }
+
+        it { should be_false }
+      end
+
+      describe 'with a matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 0)) }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 1)) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil field' do
+        subject { @comparison.matches?(@property.field => nil) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil attribute' do
+        subject { @comparison.matches?(@model.new(@property => nil)) }
+
+        it { should be_false }
+      end
+    end
+  end
+
+  it { should respond_to(:relationship?) }
+
+  describe '#relationship?' do
+    subject { @comparison.relationship? }
+
+    it { should be_false }
+  end
+
+  it { should respond_to(:to_s) }
+
+  describe '#to_s' do
+    subject { @comparison.to_s }
+
+    it { should == 'id < 1' }
+  end
+end
+
+describe DataMapper::Query::Conditions::GreaterThanOrEqualToComparison do
+  it_should_behave_like 'DataMapper::Query::Conditions::AbstractComparison'
+
+  before do
+    @property       = @model.properties[:id]
+    @other_property = @model.properties[:title]
+    @value          = 1
+    @other_value    = 2
+    @slug           = :gte
+    @comparison     = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+    @other          = OtherComparison.new(@property, @value)
+  end
+
+  subject { @comparison }
+
+  it { should respond_to(:inspect) }
+
+  describe '#inspect' do
+    subject { @comparison.inspect }
+
+    it { should == '#<DataMapper::Query::Conditions::GreaterThanOrEqualToComparison @subject=#<DataMapper::Property @model=Blog::Article @name=:id> @dumped_value=1 @loaded_value=1>' }
+  end
+
+  it { should respond_to(:matches?) }
+
+  describe '#matches?' do
+    supported_by :all do
+      describe 'with a matching Hash' do
+        subject { @comparison.matches?(@property.field => 1) }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Hash' do
+        subject { @comparison.matches?(@property.field => 0) }
+
+        it { should be_false }
+      end
+
+      describe 'with a matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 1)) }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 0)) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil field' do
+        subject { @comparison.matches?(@property.field => nil) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil attribute' do
+        subject { @comparison.matches?(@model.new(@property => nil)) }
+
+        it { should be_false }
+      end
+    end
+  end
+
+  it { should respond_to(:relationship?) }
+
+  describe '#relationship?' do
+    subject { @comparison.relationship? }
+
+    it { should be_false }
+  end
+
+  it { should respond_to(:to_s) }
+
+  describe '#to_s' do
+    subject { @comparison.to_s }
+
+    it { should == 'id >= 1' }
+  end
+end
+
+describe DataMapper::Query::Conditions::LessThanOrEqualToComparison do
+  it_should_behave_like 'DataMapper::Query::Conditions::AbstractComparison'
+
+  before do
+    @property       = @model.properties[:id]
+    @other_property = @model.properties[:title]
+    @value          = 1
+    @other_value    = 2
+    @slug           = :lte
+    @comparison     = DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)
+    @other          = OtherComparison.new(@property, @value)
+  end
+
+  subject { @comparison }
+
+  it { should respond_to(:inspect) }
+
+  describe '#inspect' do
+    subject { @comparison.inspect }
+
+    it { should == '#<DataMapper::Query::Conditions::LessThanOrEqualToComparison @subject=#<DataMapper::Property @model=Blog::Article @name=:id> @dumped_value=1 @loaded_value=1>' }
+  end
+
+  it { should respond_to(:matches?) }
+
+  describe '#matches?' do
+    supported_by :all do
+      describe 'with a matching Hash' do
+        subject { @comparison.matches?(@property.field => 1) }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Hash' do
+        subject { @comparison.matches?(@property.field => 2) }
+
+        it { should be_false }
+      end
+
+      describe 'with a matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 1)) }
+
+        it { should be_true }
+      end
+
+      describe 'with a not matching Resource' do
+        subject { @comparison.matches?(@model.new(@property => 2)) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil field' do
+        subject { @comparison.matches?(@property.field => nil) }
+
+        it { should be_false }
+      end
+
+      describe 'with a not matching nil attribute' do
+        subject { @comparison.matches?(@model.new(@property => nil)) }
+
+        it { should be_false }
+      end
+    end
+  end
+
+  it { should respond_to(:relationship?) }
+
+  describe '#relationship?' do
+    subject { @comparison.relationship? }
+
+    it { should be_false }
+  end
+
+  it { should respond_to(:to_s) }
+
+  describe '#to_s' do
+    subject { @comparison.to_s }
+
+    it { should == 'id <= 1' }
+  end
+end