ardm-core 1.2.1

data/spec/semipublic/property/text_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe DataMapper::Property::Text do
+  before :all do
+    @name          = :title
+    @type          = described_class
+    @value         = 'value'
+    @other_value   = 'return value'
+    @invalid_value = 1
+  end
+
+  it_should_behave_like 'A semipublic Property'
+
+  describe '#load' do
+    before :all do
+      @value = mock('value')
+    end
+
+    subject { @property.load(@value) }
+
+    before do
+      @property = @type.new(@model, @name)
+    end
+
+    it 'should delegate to #type.load' do
+      return_value = mock('return value')
+      @property.should_receive(:load).with(@value).and_return(return_value)
+      should == return_value
+    end
+  end
+end

data/spec/semipublic/property/time_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe DataMapper::Property::Time do
+  before :all do
+    @name          = :deleted_at
+    @type          = described_class
+    @value         = Time.now
+    @other_value   = Time.now + 15
+    @invalid_value = 1
+  end
+
+  it_should_behave_like 'A semipublic Property'
+
+  describe '#typecast_to_primitive' do
+    describe 'and value given as a hash with keys like :year, :month, etc' do
+      it 'builds a Time instance from hash values' do
+        result = @property.typecast(
+          'year'  => '2006',
+          'month' => '11',
+          'day'   => '23',
+          'hour'  => '12',
+          'min'   => '0',
+          'sec'   => '0'
+        )
+
+        result.should be_kind_of(Time)
+        result.year.should  eql(2006)
+        result.month.should eql(11)
+        result.day.should   eql(23)
+        result.hour.should  eql(12)
+        result.min.should   eql(0)
+        result.sec.should   eql(0)
+      end
+    end
+
+    describe 'and value is a string' do
+      it 'parses the string' do
+        result = @property.typecast('22:24')
+        result.hour.should eql(22)
+        result.min.should eql(24)
+      end
+    end
+
+    it 'does not typecast non-time values' do
+      pending_if 'Time#parse is too permissive', RUBY_VERSION <= '1.9.1' do
+        @property.typecast('not-time').should eql('not-time')
+      end
+    end
+  end
+end

data/spec/semipublic/property_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+# instance methods
+describe DataMapper::Property do
+  describe ".find_class" do
+    [ :Serial, :Text ].each do |type|
+      describe "with #{type}" do
+        subject { DataMapper::Property.find_class(type) }
+
+        it { subject.should be(DataMapper::Property.const_get(type)) }
+      end
+    end
+  end
+
+  describe ".determine_class" do
+    [ Integer, String, Float, Class, String, Time, DateTime, Date ].each do |type|
+      describe "with #{type}" do
+        subject { DataMapper::Property.determine_class(type) }
+
+        it { subject.should be(DataMapper::Property.const_get(type.name)) }
+      end
+    end
+
+    describe "with property subclasses" do
+      before :all do
+        Object.send(:remove_const, :CustomProps) if Object.const_defined?(:CustomProps)
+
+        module ::CustomProps
+          module Property
+            class Hash   < DataMapper::Property::Object; end
+            class Other  < DataMapper::Property::Object; end
+            class Serial < DataMapper::Property::Object; end
+          end
+        end
+      end
+
+      describe "with ::Foo::Property::Hash" do
+        subject { DataMapper::Property.determine_class(Hash) }
+
+        it { subject.should be(::CustomProps::Property::Hash) }
+      end
+
+      describe "with ::Foo::Property::Other" do
+        subject { DataMapper::Property.determine_class(::CustomProps::Property::Other) }
+
+        it { subject.should be(::CustomProps::Property::Other) }
+      end
+
+      describe "should always use the DM property when a built-in is referenced indirectly" do
+        subject do
+          Class.new do
+            extend ::DataMapper::Model
+          end
+        end
+
+        it { subject::Serial.should be(::DataMapper::Property::Serial) }
+      end
+
+      describe "should always use the custom property when an overridden built-in is directly attached to the model" do
+        subject do
+          Class.new do
+            extend ::DataMapper::Model
+            include ::CustomProps::Property
+          end
+        end
+
+        it { subject::Serial.should be(::CustomProps::Property::Serial) }
+      end
+
+    end
+  end
+
+  before :all do
+    module ::Blog
+      class Author
+        include DataMapper::Resource
+
+        property :id,         Integer, :key => true
+        property :name,       String
+        property :rating,     Float
+        property :rate,       Decimal, :precision => 5, :scale => 2
+        property :type,       Class
+        property :alias,      String
+        property :active,     Boolean
+        property :deleted_at, Time
+        property :created_at, DateTime
+        property :created_on, Date
+        property :info,       Text
+      end
+    end
+
+    @model = Blog::Author
+  end
+
+  describe 'override property definition in other repository' do
+    before :all do
+      module ::Blog
+        class Author
+          repository(:other) do
+            property :name,  String, :key => true, :field => 'other_name'
+          end
+        end
+      end
+    end
+
+    it 'should return property options in other repository' do
+      @model.properties(:other)[:name].options[:field].should == 'other_name'
+    end
+
+    it 'should return property options in default repository' do
+      @model.properties[:name].options[:field].should be_nil
+    end
+  end
+end

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

@@ -0,0 +1,1501 @@
+require 'spec_helper'
+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
+    DataMapper.finalize
+
+    @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::Serial @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 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 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 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
+      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::Serial @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
+      supported_by :all 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
+  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::String @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::String @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::Serial @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
+
+      describe 'with an expected value of nil' do
+        subject { @comparison.matches?(@model.new(@property => 2)) }
+
+        before do
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, nil)
+        end
+
+        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::Serial @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
+
+      describe 'with an expected value of nil' do
+        subject { @comparison.matches?(@model.new(@property => 0)) }
+
+        before do
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, nil)
+        end
+
+        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::Serial @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
+
+      describe 'with an expected value of nil' do
+        subject { @comparison.matches?(@model.new(@property => 1)) }
+
+        before do
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, nil)
+        end
+
+        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::Serial @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
+
+      describe 'with an expected value of nil' do
+        subject { @comparison.matches?(@model.new(@property => 1)) }
+
+        before do
+          @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, nil)
+        end
+
+        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