dm-hibernate-adapter 0.1pre-java

data/spec/transient/rcov.opts

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

data/spec/transient/shared/adapter_shared_spec.rb

@@ -0,0 +1,408 @@
+share_examples_for 'An Adapter' do
+
+  def self.adapter_supports?(*methods)
+    methods.all? do |method|
+      # TODO: figure out a way to see if the instance method is only inherited
+      # from the Abstract Adapter, and not defined in it's class.  If that is
+      # the case return false
+
+      # CRUD methods can be inherited from parent class
+      described_type.instance_methods.any? { |instance_method| method.to_s == instance_method.to_s }
+    end
+  end
+
+  before(:all) do
+
+    raise '+@adapter+ should be defined in before block' unless instance_variable_get('@adapter')
+
+    class ::Heffalump
+      include DataMapper::Resource
+
+      property :id,        Serial
+      property :color,     String
+      property :num_spots, Integer
+      property :striped,   Boolean
+
+    end
+
+    # TODO ?
+    # if @repository.respond_to?(:auto_migrate!)
+      Heffalump.auto_migrate!
+    # end
+  end
+
+  if adapter_supports?(:create)
+    describe '#create' do
+      it 'should not raise any errors' do
+        lambda {
+          Heffalump.create(:color => 'peach')
+        }.should_not raise_error
+      end
+
+      it 'should set the identity field for the resource' do
+        heffalump = Heffalump.new(:color => 'peach')
+        heffalump.id.should be_nil
+        heffalump.save
+        heffalump.id.should_not be_nil
+      end
+    end
+  else
+    it 'needs to support #create'
+  end
+
+  if adapter_supports?(:read)
+
+   # <added>
+    # XXX this part is added to dm_core's specs
+    describe '#read specific object' do
+      before :all do
+        @heffalump = Heffalump.create(:color => 'brownish hue')
+        #just going to borrow this, so I can check the return values
+        @query = Heffalump.all.query
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          Heffalump.get(@heffalump.id)
+        }.should_not raise_error
+      end
+
+      it 'should raise ObjectNotFoundError' do
+        lambda {
+          id =  -600
+          Heffalump.get!(id)
+        }.should raise_error(DataMapper::ObjectNotFoundError)
+      end
+
+      it 'should return correct result' do
+        id = @heffalump.id
+        Heffalump.get(id).id.should == id
+      end
+
+    end
+    # </added>
+
+    describe '#read' do
+      before :all do
+        @heffalump = Heffalump.create(:color => 'brownish hue')
+        #just going to borrow this, so I can check the return values
+        @query = Heffalump.all.query
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          Heffalump.all()
+        }.should_not raise_error
+      end
+
+      it 'should return stuff' do
+        Heffalump.all.should be_include(@heffalump)
+      end
+    end
+  else
+    it 'needs to support #read'
+  end
+
+  if adapter_supports?(:update)
+
+    # <added>
+    # XXX this part is added to dm_core's specs
+    describe '#update called directly' do
+      before do
+        @heffalump = Heffalump.create(:color => 'indigo')
+      end
+
+      it 'should not raise any errors' do
+        lambda{
+          @heffalump.update(:color => 'violet')
+        }.should_not raise_error
+      end
+
+      it 'should not alter the identity field' do
+        id = @heffalump.id
+        @heffalump.update(:color => 'violet')
+        @heffalump.id.should == id
+      end
+
+      it 'should update altered fields' do
+        @heffalump.update(:color => 'violet')
+        Heffalump.get(*@heffalump.key).color.should == 'violet'
+      end
+
+      it 'should not alter other fields' do
+        color = @heffalump.color
+        @heffalump.update(:num_spots => 567)
+        Heffalump.get(*@heffalump.key).color.should == color
+      end
+
+    end
+    # </added>
+
+    describe '#update' do
+      before do
+        @heffalump = Heffalump.create(:color => 'indigo')
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          @heffalump.color = 'violet'
+          @heffalump.save
+        }.should_not raise_error
+      end
+
+      it 'should not alter the identity field' do
+        id = @heffalump.id
+        @heffalump.color = 'violet'
+        @heffalump.save
+        @heffalump.id.should == id
+      end
+
+      it 'should update altered fields' do
+        @heffalump.color = 'violet'
+        @heffalump.save
+        Heffalump.get(*@heffalump.key).color.should == 'violet'
+      end
+
+      it 'should not alter other fields' do
+        color = @heffalump.color
+        @heffalump.num_spots = 3
+        @heffalump.save
+        Heffalump.get(*@heffalump.key).color.should == color
+      end
+    end
+  else
+    it 'needs to support #update'
+  end
+
+  if adapter_supports?(:delete)
+    describe '#delete' do
+      before do
+        @heffalump = Heffalump.create(:color => 'forest green')
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          @heffalump.destroy
+        }.should_not raise_error
+      end
+
+      it 'should delete the requested resource' do
+        id = @heffalump.id
+        @heffalump.destroy
+        Heffalump.get(id).should be_nil
+      end
+    end
+  else
+    it 'needs to support #delete'
+  end
+
+  if adapter_supports?(:read, :create)
+    describe 'query matching' do
+      before :all do
+        @red = Heffalump.create(:color => 'red')
+        @two = Heffalump.create(:num_spots => 2)
+        @five = Heffalump.create(:num_spots => 5)
+      end
+
+      describe 'conditions' do
+        describe 'eql' do
+          it 'should be able to search for objects included in an inclusive range of values' do
+            Heffalump.all(:num_spots => 1..5).should be_include(@five)
+          end
+
+          it 'should be able to search for objects included in an exclusive range of values' do
+            Heffalump.all(:num_spots => 1...6).should be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an inclusive range of values' do
+            Heffalump.all(:num_spots => 1..4).should_not be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an exclusive range of values' do
+            Heffalump.all(:num_spots => 1...5).should_not be_include(@five)
+          end
+        end
+
+        describe 'not' do
+          it 'should be able to search for objects with not equal value' do
+            Heffalump.all(:color.not => 'red').should_not be_include(@red)
+          end
+
+          it 'should include objects that are not like the value' do
+            Heffalump.all(:color.not => 'black').should be_include(@red)
+          end
+
+          it 'should be able to search for objects with not nil value' do
+            Heffalump.all(:color.not => nil).should be_include(@red)
+          end
+
+          it 'should not include objects with a nil value' do
+            Heffalump.all(:color.not => nil).should_not be_include(@two)
+          end
+
+          it 'should be able to search for object with a nil value using required properties' do
+            Heffalump.all(:id.not => nil).should == [ @red, @two, @five ]
+          end
+
+          # XXX That case generates SICK sql code !
+          it 'should be able to search for objects not in an empty list (match all)' do
+            Heffalump.all(:color.not => []).should == [ @red, @two, @five ]
+          end
+
+          it 'should be able to search for objects in an empty list and another OR condition (match none on the empty list)' do
+            Heffalump.all(:conditions => DataMapper::Query::Conditions::Operation.new(
+                                           :or,
+                                           DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:color], []),
+                                           DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:num_spots], [5]))).should == [ @five ]
+          end
+
+          it 'should be able to search for objects not included in an array of values' do
+            Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should be_include(@two)
+          end
+
+          it 'should be able to search for objects not included in an array of values' do
+            Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should_not be_include(@five)
+          end
+
+          it 'should be able to search for objects not included in an inclusive range of values' do
+            Heffalump.all(:num_spots.not => 1..4).should be_include(@five)
+          end
+
+          it 'should be able to search for objects not included in an exclusive range of values' do
+            Heffalump.all(:num_spots.not => 1...5).should be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an inclusive range of values' do
+            Heffalump.all(:num_spots.not => 1..5).should_not be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an exclusive range of values' do
+            Heffalump.all(:num_spots.not => 1...6).should_not be_include(@five)
+          end
+        end
+
+        describe 'like' do
+          it 'should be able to search for objects that match value' do
+            Heffalump.all(:color.like => '%ed').should be_include(@red)
+          end
+
+          it 'should not search for objects that do not match the value' do
+            Heffalump.all(:color.like => '%blak%').should_not be_include(@red)
+          end
+        end
+
+        # <added>
+        # XXX this part is added to dm_core's specs
+        # XX ie. HSQLDB support "Java" regexps only
+        describe 'Java regexp' do
+          before do
+            if (defined?(DataMapper::Adapters::Sqlite3Adapter) && @adapter.kind_of?(DataMapper::Adapters::Sqlite3Adapter) ||
+                defined?(DataMapper::Adapters::SqlserverAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter))
+              pending 'delegate regexp matches to same system that the InMemory and YAML adapters use'
+            end
+          end
+
+          it 'should be able to search for objects that match value' do
+            Heffalump.all(:color => /.*ed.*/).should be_include(@red)
+          end
+
+          it 'should not be able to search for objects that do not match the value' do
+            Heffalump.all(:color => /.*blak.*/).should_not be_include(@red)
+          end
+
+          it 'should be able to do a negated search for objects that match value' do
+            Heffalump.all(:color.not => /.*blak.*/).should be_include(@red)
+          end
+
+          it 'should not be able to do a negated search for objects that do not match value' do
+            Heffalump.all(:color.not => /.*ed.*/).should_not be_include(@red)
+          end
+
+        end
+        # <added>
+
+        describe 'regexp' do
+          before do
+            if (defined?(DataMapper::Adapters::Sqlite3Adapter) && @adapter.kind_of?(DataMapper::Adapters::Sqlite3Adapter) ||
+                defined?(DataMapper::Adapters::SqlserverAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter))
+              pending 'delegate regexp matches to same system that the InMemory and YAML adapters use'
+            end
+          end
+
+          it 'should be able to search for objects that match value' do
+            Heffalump.all(:color => /ed/).should be_include(@red)
+          end
+
+          it 'should not be able to search for objects that do not match the value' do
+            Heffalump.all(:color => /blak/).should_not be_include(@red)
+          end
+
+          it 'should be able to do a negated search for objects that match value' do
+            Heffalump.all(:color.not => /blak/).should be_include(@red)
+          end
+
+          it 'should not be able to do a negated search for objects that do not match value' do
+            Heffalump.all(:color.not => /ed/).should_not be_include(@red)
+          end
+
+        end
+
+        describe 'gt' do
+          it 'should be able to search for objects with value greater than' do
+            Heffalump.all(:num_spots.gt => 1).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gt => 3).should_not be_include(@two)
+          end
+        end
+
+        describe 'gte' do
+          it 'should be able to search for objects with value greater than' do
+            Heffalump.all(:num_spots.gte => 1).should be_include(@two)
+          end
+
+          it 'should be able to search for objects with values equal to' do
+            Heffalump.all(:num_spots.gte => 2).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gte => 3).should_not be_include(@two)
+          end
+        end
+
+        describe 'lt' do
+          it 'should be able to search for objects with value less than' do
+            Heffalump.all(:num_spots.lt => 3).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gt => 2).should_not be_include(@two)
+          end
+        end
+
+        describe 'lte' do
+          it 'should be able to search for objects with value less than' do
+            Heffalump.all(:num_spots.lte => 3).should be_include(@two)
+          end
+
+          it 'should be able to search for objects with values equal to' do
+            Heffalump.all(:num_spots.lte => 2).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.lte => 1).should_not be_include(@two)
+          end
+        end
+      end
+
+      describe 'limits' do
+        it 'should be able to limit the objects' do
+          Heffalump.all(:limit => 2).length.should == 2
+        end
+      end
+    end
+  else
+    it 'needs to support #read and #create to test query matching'
+  end
+end

data/spec/transient/shared/finder_shared_spec.rb

@@ -0,0 +1,1513 @@
+share_examples_for 'Finder Interface' do
+  before :all do
+    %w[ @article_model @article @other @articles ].each do |ivar|
+      raise "+#{ivar}+ should be defined in before block" unless instance_variable_defined?(ivar)
+      raise "+#{ivar}+ should not be nil in before block" unless instance_variable_get(ivar)
+    end
+  end
+
+  before :all do
+    @no_join = defined?(DataMapper::Adapters::InMemoryAdapter) && @adapter.kind_of?(DataMapper::Adapters::InMemoryAdapter) ||
+               defined?(DataMapper::Adapters::YamlAdapter)     && @adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+
+    @do_adapter = defined?(DataMapper::Adapters::DataObjectsAdapter) && @adapter.kind_of?(DataMapper::Adapters::DataObjectsAdapter)
+
+    @many_to_many = @articles.kind_of?(DataMapper::Associations::ManyToMany::Collection)
+
+    @skip = @no_join && @many_to_many
+  end
+
+  before do
+    pending if @skip
+  end
+
+  [ :[], :slice ].each do |method|
+    it { @articles.should respond_to(method) }
+
+    describe "##{method}" do
+      before :all do
+        1.upto(10) { |number| @articles.create(:content => "Article #{number}") }
+        @copy = @articles.kind_of?(Class) ? @articles : @articles.dup
+      end
+
+      describe 'with a positive offset' do
+        before :all do
+          unless @skip
+            @return = @resource = @articles.send(method, 0)
+          end
+        end
+
+        it 'should return a Resource' do
+          @return.should be_kind_of(DataMapper::Resource)
+        end
+
+        it 'should return expected Resource' do
+          @return.should == @copy.entries.send(method, 0)
+        end
+      end
+
+      describe 'with a positive offset and length' do
+        before :all do
+          @return = @resources = @articles.send(method, 5, 5)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return the expected Resource' do
+          @return.should == @copy.entries.send(method, 5, 5)
+        end
+
+        it 'should scope the Collection' do
+          @resources.reload.should == @copy.entries.send(method, 5, 5)
+        end
+      end
+
+      describe 'with a positive range' do
+        before :all do
+          @return = @resources = @articles.send(method, 5..10)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return the expected Resources' do
+          @return.should == @copy.entries.send(method, 5..10)
+        end
+
+        it 'should scope the Collection' do
+          @resources.reload.should == @copy.entries.send(method, 5..10)
+        end
+      end
+
+      describe 'with a negative offset' do
+        before :all do
+          unless @skip
+            @return = @resource = @articles.send(method, -1)
+          end
+        end
+
+        it 'should return a Resource' do
+          @return.should be_kind_of(DataMapper::Resource)
+        end
+
+        it 'should return expected Resource' do
+          @return.should == @copy.entries.send(method, -1)
+        end
+      end
+
+      describe 'with a negative offset and length' do
+        before :all do
+          @return = @resources = @articles.send(method, -5, 5)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return the expected Resources' do
+          @return.should == @copy.entries.send(method, -5, 5)
+        end
+
+        it 'should scope the Collection' do
+          @resources.reload.should == @copy.entries.send(method, -5, 5)
+        end
+      end
+
+      describe 'with a negative range' do
+        before :all do
+          @return = @resources = @articles.send(method, -5..-2)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return the expected Resources' do
+          @return.to_a.should == @copy.entries.send(method, -5..-2)
+        end
+
+        it 'should scope the Collection' do
+          @resources.reload.should == @copy.entries.send(method, -5..-2)
+        end
+      end
+
+      describe 'with an empty exclusive range' do
+        before :all do
+          @return = @resources = @articles.send(method, 0...0)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return the expected value' do
+          @return.to_a.should == @copy.entries.send(method, 0...0)
+        end
+
+        it 'should be empty' do
+          @return.should be_empty
+        end
+      end
+
+      describe 'with an offset not within the Collection' do
+        before :all do
+          unless @skip
+            @return = @articles.send(method, 99)
+          end
+        end
+
+        it 'should return nil' do
+          @return.should be_nil
+        end
+      end
+
+      describe 'with an offset and length not within the Collection' do
+        before :all do
+          @return = @articles.send(method, 99, 1)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be empty' do
+          @return.should be_empty
+        end
+      end
+
+      describe 'with a range not within the Collection' do
+        before :all do
+          @return = @articles.send(method, 99..100)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be empty' do
+          @return.should be_empty
+        end
+      end
+    end
+  end
+
+  it { @articles.should respond_to(:all) }
+
+  describe '#all' do
+    describe 'with no arguments' do
+      before :all do
+        @copy = @articles.kind_of?(Class) ? @articles : @articles.dup
+
+        @return = @collection = @articles.all
+      end
+
+      it 'should return a Collection' do
+        @return.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should return a new instance' do
+        @return.should_not equal(@articles)
+      end
+
+      it 'should be expected Resources' do
+        @collection.should == @articles.entries
+      end
+
+      it 'should not have a Query the same as the original' do
+        @return.query.should_not equal(@articles.query)
+      end
+
+      it 'should have a Query equal to the original' do
+        @return.query.should eql(@articles.query)
+      end
+
+      it 'should scope the Collection' do
+        @collection.reload.should == @copy.entries
+      end
+    end
+
+    describe 'with a query' do
+      before :all do
+        @new  = @articles.create(:content => 'New Article')
+        @copy = @articles.kind_of?(Class) ? @articles : @articles.dup
+
+        @return = @articles.all(:content => [ 'New Article' ])
+      end
+
+      it 'should return a Collection' do
+        @return.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should return a new instance' do
+        @return.should_not equal(@articles)
+      end
+
+      it 'should be expected Resources' do
+        @return.should == [ @new ]
+      end
+
+      it 'should have a different query than original Collection' do
+        @return.query.should_not equal(@articles.query)
+      end
+
+      it 'should scope the Collection' do
+        @return.reload.should == @copy.entries.select { |resource| resource.content == 'New Article' }
+      end
+    end
+
+    describe 'with a query using raw conditions' do
+      before do
+        pending unless defined?(DataMapper::Adapters::DataObjectsAdapter) && @adapter.kind_of?(DataMapper::Adapters::DataObjectsAdapter)
+      end
+
+      before :all do
+        @new  = @articles.create(:subtitle => 'New Article')
+        @copy = @articles.kind_of?(Class) ? @articles : @articles.dup
+
+        @return = @articles.all(:conditions => [ 'subtitle = ?', 'New Article' ])
+      end
+
+      it 'should return a Collection' do
+        @return.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should return a new instance' do
+        @return.should_not equal(@articles)
+      end
+
+      it 'should be expected Resources' do
+        @return.should == [ @new ]
+      end
+
+      it 'should have a different query than original Collection' do
+        @return.query.should_not == @articles.query
+      end
+
+      it 'should scope the Collection' do
+        @return.reload.should == @copy.entries.select { |resource| resource.subtitle == 'New Article' }.first(1)
+      end
+    end
+
+    describe 'with a query that is out of range' do
+      it 'should raise an exception' do
+        lambda {
+          @articles.all(:limit => 10).all(:offset => 10)
+        }.should raise_error(RangeError, 'offset 10 and limit 0 are outside allowed range')
+      end
+    end
+
+    describe 'with a query using a m:1 relationship' do
+      describe 'with a Hash' do
+        before :all do
+          @return = @articles.all(:original => @original.attributes)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          @return.should == [ @article ]
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+      end
+
+      describe 'with a resource' do
+        before :all do
+          @return = @articles.all(:original => @original)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          @return.should == [ @article ]
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+      end
+
+      describe 'with a collection' do
+        before :all do
+          @collection = @article_model.all(@article_model.key.zip(@original.key).to_hash)
+
+          @return = @articles.all(:original => @collection)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          @return.should == [ @article ]
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+
+      end
+
+      describe 'with an empty Array' do
+        before :all do
+          @return = @articles.all(:original => [])
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be an empty Collection' do
+          @return.should be_empty
+        end
+
+        it 'should not have a valid query' do
+          @return.query.should_not be_valid
+        end
+      end
+
+      describe 'with a nil value' do
+        before :all do
+          @return = @articles.all(:original => nil)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        if respond_to?(:model?) && model?
+          it 'should be expected Resources' do
+            @return.should == [ @original, @other ]
+          end
+        else
+          it 'should be an empty Collection' do
+            @return.should be_empty
+          end
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+
+        it 'should be equivalent to negated collection query' do
+          pending_if 'Update RDBMS to match ruby behavior', @do_adapter && @articles.kind_of?(DataMapper::Model) do
+            # NOTE: the second query will not match any articles where original_id
+            # is nil, while the in-memory/yaml adapters will.  RDBMS will explicitly
+            # filter out NULL matches because we are matching on a non-NULL value,
+            # which is not consistent with how DM/Ruby matching behaves.
+            @return.should == @articles.all(:original.not => @article_model.all)
+          end
+        end
+      end
+
+      describe 'with a negated nil value' do
+        before :all do
+          @return = @articles.all(:original.not => nil)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          @return.should == [ @article ]
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+
+        it 'should be equivalent to collection query' do
+          @return.should == @articles.all(:original => @article_model.all)
+        end
+      end
+    end
+
+    describe 'with a query using a 1:1 relationship' do
+      before :all do
+        @new = @articles.create(:content => 'New Article', :original => @article)
+      end
+
+      describe 'with a Hash' do
+        before :all do
+          @return = @articles.all(:previous => @new.attributes)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          @return.should == [ @article ]
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+      end
+
+      describe 'with a resource' do
+        before :all do
+          @return = @articles.all(:previous => @new)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          @return.should == [ @article ]
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+      end
+
+      describe 'with a collection' do
+        before :all do
+          @collection = @article_model.all(@article_model.key.zip(@new.key).to_hash)
+
+          @return = @articles.all(:previous => @collection)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          @return.should == [ @article ]
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+      end
+
+      describe 'with an empty Array' do
+        before :all do
+          @return = @articles.all(:previous => [])
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be an empty Collection' do
+          @return.should be_empty
+        end
+
+        it 'should not have a valid query' do
+          @return.query.should_not be_valid
+        end
+      end
+
+      describe 'with a nil value' do
+        before :all do
+          @return = @articles.all(:previous => nil)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        if respond_to?(:model?) && model?
+          it 'should be expected Resources' do
+            @return.should == [ @other, @new ]
+          end
+        else
+          it 'should be expected Resources' do
+            @return.should == [ @new ]
+          end
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+
+        it 'should be equivalent to negated collection query' do
+          @return.should == @articles.all(:previous.not => @article_model.all(:original.not => nil))
+        end
+      end
+
+      describe 'with a negated nil value' do
+        before :all do
+          @return = @articles.all(:previous.not => nil)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        if respond_to?(:model?) && model?
+          it 'should be expected Resources' do
+            @return.should == [ @original, @article ]
+          end
+        else
+          it 'should be expected Resources' do
+            @return.should == [ @article ]
+          end
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+
+        it 'should be equivalent to collection query' do
+          @return.should == @articles.all(:previous => @article_model.all)
+        end
+      end
+    end
+
+    describe 'with a query using a 1:m relationship' do
+      before :all do
+        @new = @articles.create(:content => 'New Article', :original => @article)
+      end
+
+      describe 'with a Hash' do
+        before :all do
+          @return = @articles.all(:revisions => @new.attributes)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          @return.should == [ @article ]
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+      end
+
+      describe 'with a resource' do
+        before :all do
+          @return = @articles.all(:revisions => @new)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          @return.should == [ @article ]
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+      end
+
+      describe 'with a collection' do
+        before :all do
+          @collection = @article_model.all(@article_model.key.zip(@new.key).to_hash)
+
+          @return = @articles.all(:revisions => @collection)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          @return.should == [ @article ]
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+      end
+
+      describe 'with an empty Array' do
+        before :all do
+          @return = @articles.all(:revisions => [])
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be an empty Collection' do
+          @return.should be_empty
+        end
+
+        it 'should not have a valid query' do
+          @return.query.should_not be_valid
+        end
+      end
+
+      describe 'with a nil value' do
+        before :all do
+          @return = @articles.all(:revisions => nil)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        if respond_to?(:model?) && model?
+          it 'should be expected Resources' do
+            @return.should == [ @other, @new ]
+          end
+        else
+          it 'should be expected Resources' do
+            @return.should == [ @new ]
+          end
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+
+        it 'should be equivalent to negated collection query' do
+          @return.should == @articles.all(:revisions.not => @article_model.all(:original.not => nil))
+        end
+      end
+
+      describe 'with a negated nil value' do
+        before :all do
+          @return = @articles.all(:revisions.not => nil)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        if respond_to?(:model?) && model?
+          it 'should be expected Resources' do
+            @return.should == [ @original, @article ]
+          end
+        else
+          it 'should be expected Resources' do
+            @return.should == [ @article ]
+          end
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+
+        it 'should be equivalent to collection query' do
+          @return.should == @articles.all(:revisions => @article_model.all)
+        end
+      end
+    end
+
+    describe 'with a query using a m:m relationship' do
+      before :all do
+        @publication = @article.publications.create(:name => 'DataMapper Now')
+      end
+
+      describe 'with a Hash' do
+        before :all do
+          @return = @articles.all(:publications => @publication.attributes)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          pending 'TODO' do
+            @return.should == [ @article ]
+          end
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+      end
+
+      describe 'with a resource' do
+        before :all do
+          @return = @articles.all(:publications => @publication)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          pending 'TODO' do
+            @return.should == [ @article ]
+          end
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+      end
+
+      describe 'with a collection' do
+        before :all do
+          @collection = @publication_model.all(@publication_model.key.zip(@publication.key).to_hash)
+
+          @return = @articles.all(:publications => @collection)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          pending 'TODO' do
+            @return.should == [ @article ]
+          end
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+      end
+
+      describe 'with an empty Array' do
+        before :all do
+          @return = @articles.all(:publications => [])
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be an empty Collection' do
+          @return.should be_empty
+        end
+
+        it 'should not have a valid query' do
+          @return.query.should_not be_valid
+        end
+      end
+
+      describe 'with a nil value' do
+        before :all do
+          @return = @articles.all(:publications => nil)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be empty' do
+          pending 'TODO' do
+            @return.should be_empty
+          end
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+
+        it 'should be equivalent to negated collection query' do
+          @return.should == @articles.all(:publications.not => @publication_model.all)
+        end
+      end
+
+      describe 'with a negated nil value' do
+        before :all do
+          @return = @articles.all(:publications.not => nil)
+        end
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should be expected Resources' do
+          pending 'TODO' do
+            @return.should == [ @article ]
+          end
+        end
+
+        it 'should have a valid query' do
+          @return.query.should be_valid
+        end
+
+        it 'should be equivalent to collection query' do
+          @return.should == @articles.all(:publications => @publication_model.all)
+        end
+      end
+    end
+  end
+
+  it { @articles.should respond_to(:at) }
+
+  describe '#at' do
+    before :all do
+      @copy = @articles.kind_of?(Class) ? @articles : @articles.dup
+      @copy.to_a
+    end
+
+    describe 'with positive offset' do
+      before :all do
+        @return = @resource = @articles.at(0)
+      end
+
+      should_not_be_a_kicker
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should return expected Resource' do
+        @resource.should == @copy.entries.at(0)
+      end
+    end
+
+    describe 'with negative offset' do
+      before :all do
+        @return = @resource = @articles.at(-1)
+      end
+
+      should_not_be_a_kicker
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should return expected Resource' do
+        @resource.should == @copy.entries.at(-1)
+      end
+    end
+  end
+
+  it { @articles.should respond_to(:first) }
+
+  describe '#first' do
+    before :all do
+      1.upto(5) { |number| @articles.create(:content => "Article #{number}") }
+
+      @copy = @articles.kind_of?(Class) ? @articles : @articles.dup
+      @copy.to_a
+    end
+
+    describe 'with no arguments' do
+      before :all do
+        @return = @resource = @articles.first
+      end
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be first Resource in the Collection' do
+        @resource.should == @copy.entries.first
+      end
+    end
+
+    describe 'with empty query' do
+      before :all do
+        @return = @resource = @articles.first({})
+      end
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be first Resource in the Collection' do
+        @resource.should == @copy.entries.first
+      end
+    end
+
+    describe 'with a query' do
+      before :all do
+        @return = @resource = @articles.first(:content => 'Sample')
+      end
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should should be the first Resource in the Collection matching the query' do
+        @resource.should == @article
+      end
+    end
+
+    describe 'with a limit specified' do
+      before :all do
+        @return = @resources = @articles.first(1)
+      end
+
+      it 'should return a Collection' do
+        @return.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should be the first N Resources in the Collection' do
+        @resources.should == @copy.entries.first(1)
+      end
+    end
+
+    describe 'on an empty collection' do
+      before :all do
+        @articles = @articles.all(:id => nil)
+        @return = @articles.first
+      end
+
+      it 'should still be an empty collection' do
+        @articles.should be_empty
+      end
+
+      it 'should return nil' do
+        @return.should be_nil
+      end
+    end
+
+    describe 'with offset specified' do
+      before :all do
+        @return = @resource = @articles.first(:offset => 1)
+      end
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be the second Resource in the Collection' do
+        @resource.should == @copy.entries[1]
+      end
+    end
+
+    describe 'with a limit and query specified' do
+      before :all do
+        @return = @resources = @articles.first(1, :content => 'Sample')
+      end
+
+      it 'should return a Collection' do
+        @return.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should be the first N Resources in the Collection matching the query' do
+        @resources.should == [ @article ]
+      end
+    end
+  end
+
+  it { @articles.should respond_to(:first_or_create) }
+
+  describe '#first_or_create' do
+    describe 'with conditions that find an existing Resource' do
+      before :all do
+        @return = @resource = @articles.first_or_create(@article.attributes)
+      end
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be expected Resource' do
+        @resource.should == @article
+      end
+
+      it 'should be a saved Resource' do
+        @resource.should be_saved
+      end
+    end
+
+    describe 'with conditions that do not find an existing Resource' do
+      before :all do
+        @conditions = { :content => 'Unknown Content' }
+        @attributes = {}
+
+        @return = @resource = @articles.first_or_create(@conditions, @attributes)
+      end
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be expected Resource' do
+        @resource.attributes.only(*@conditions.keys).should == @conditions
+      end
+
+      it 'should be a saved Resource' do
+        @resource.should be_saved
+      end
+    end
+  end
+
+  it { @articles.should respond_to(:first_or_new) }
+
+  describe '#first_or_new' do
+    describe 'with conditions that find an existing Resource' do
+      before :all do
+        @return = @resource = @articles.first_or_new(@article.attributes)
+      end
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be expected Resource' do
+        @resource.should == @article
+      end
+
+      it 'should be a saved Resource' do
+        @resource.should be_saved
+      end
+    end
+
+    describe 'with conditions that do not find an existing Resource' do
+      before :all do
+        @conditions = { :content => 'Unknown Content' }
+        @attributes = {}
+
+        @return = @resource = @articles.first_or_new(@conditions, @attributes)
+      end
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be expected Resource' do
+        @resource.attributes.only(*@conditions.keys).should == @conditions
+      end
+
+      it 'should not be a saved Resource' do
+        @resource.should be_new
+      end
+    end
+  end
+
+  [ :get, :get! ].each do |method|
+    it { @articles.should respond_to(method) }
+
+    describe "##{method}" do
+      describe 'with a key to a Resource within the Collection' do
+        before :all do
+          unless @skip
+            @return = @resource = @articles.send(method, *@article.key)
+          end
+        end
+
+        it 'should return a Resource' do
+          @return.should be_kind_of(DataMapper::Resource)
+        end
+
+        it 'should be matching Resource in the Collection' do
+          @resource.should == @article
+        end
+      end
+
+      describe 'with a key not typecast' do
+        before :all do
+          unless @skip
+            @return = @resource = @articles.send(method, *@article.key.map { |value| value.to_s })
+          end
+        end
+
+        it 'should return a Resource' do
+          @return.should be_kind_of(DataMapper::Resource)
+        end
+
+        it 'should be matching Resource in the Collection' do
+          @resource.should == @article
+        end
+      end
+
+      describe 'with a key to a Resource not within the Collection' do
+        if method == :get
+          it 'should return nil' do
+            @articles.get(99).should be_nil
+          end
+        else
+          it 'should raise an exception' do
+            lambda {
+              @articles.get!(99)
+            }.should raise_error(DataMapper::ObjectNotFoundError, "Could not find #{@article_model} with key \[99\]")
+          end
+        end
+      end
+
+      describe 'with a key that is nil' do
+        if method == :get
+          it 'should return nil' do
+            @articles.get(nil).should be_nil
+          end
+        else
+          it 'should raise an exception' do
+            lambda {
+              @articles.get!(nil)
+            }.should raise_error(DataMapper::ObjectNotFoundError, "Could not find #{@article_model} with key [nil]")
+          end
+        end
+      end
+
+      describe 'with a key that is an empty String' do
+        if method == :get
+          it 'should return nil' do
+            @articles.get('').should be_nil
+          end
+        else
+          it 'should raise an exception' do
+            lambda {
+              @articles.get!('')
+            }.should raise_error(DataMapper::ObjectNotFoundError, "Could not find #{@article_model} with key [\"\"]")
+          end
+        end
+      end
+
+      describe 'with a key that has incorrect number of arguments' do
+        subject { @articles.send(method) }
+
+        it 'should raise an exception' do
+          method(:subject).should raise_error(ArgumentError, 'The number of arguments for the key is invalid, expected 1 but was 0')
+        end
+      end
+    end
+  end
+
+  it { @articles.should respond_to(:last) }
+
+  describe '#last' do
+    before :all do
+      1.upto(5) { |number| @articles.create(:content => "Article #{number}") }
+
+      @copy = @articles.kind_of?(Class) ? @articles : @articles.dup
+      @copy.to_a
+    end
+
+    describe 'with no arguments' do
+      before :all do
+        @return = @resource = @articles.last
+      end
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be last Resource in the Collection' do
+        @resource.should == @copy.entries.last
+      end
+    end
+
+    describe 'with a query' do
+      before :all do
+        @return = @resource = @articles.last(:content => 'Sample')
+      end
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should should be the last Resource in the Collection matching the query' do
+        @resource.should == @article
+      end
+    end
+
+    describe 'with a limit specified' do
+      before :all do
+        @return = @resources = @articles.last(1)
+      end
+
+      it 'should return a Collection' do
+        @return.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should be the last N Resources in the Collection' do
+        @resources.should == @copy.entries.last(1)
+      end
+    end
+
+    describe 'with offset specified' do
+      before :all do
+        @return = @resource = @articles.last(:offset => 1)
+      end
+
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be the second Resource in the Collection' do
+        @resource.should == @copy.entries[-2]
+      end
+    end
+
+    describe 'with a limit and query specified' do
+      before :all do
+        @return = @resources = @articles.last(1, :content => 'Sample')
+      end
+
+      it 'should return a Collection' do
+        @return.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should be the last N Resources in the Collection matching the query' do
+        @resources.should == [ @article ]
+      end
+    end
+  end
+
+  it { @articles.should respond_to(:reverse) }
+
+  describe '#reverse' do
+    before :all do
+      @query = @articles.query
+
+      @new = @articles.create(:title => 'Sample Article')
+
+      @return = @articles.reverse
+    end
+
+    it 'should return a Collection' do
+      @return.should be_kind_of(DataMapper::Collection)
+    end
+
+    it 'should return a Collection with reversed entries' do
+      @return.should == @articles.entries.reverse
+    end
+
+    it 'should return a Query that is the reverse of the original' do
+      @return.query.should == @query.reverse
+    end
+  end
+
+  it 'should respond to a belongs_to relationship method with #method_missing' do
+    pending_if 'Model#method_missing should delegate to relationships', @articles.kind_of?(Class) do
+      @articles.should respond_to(:original)
+    end
+  end
+
+  it 'should respond to a has n relationship method with #method_missing' do
+    pending_if 'Model#method_missing should delegate to relationships', @articles.kind_of?(Class) do
+      @articles.should respond_to(:revisions)
+    end
+  end
+
+  it 'should respond to a has 1 relationship method with #method_missing' do
+    pending_if 'Model#method_missing should delegate to relationships', @articles.kind_of?(Class) do
+      @articles.should respond_to(:previous)
+    end
+  end
+
+  describe '#method_missing' do
+    before do
+      pending 'Model#method_missing should delegate to relationships' if @articles.kind_of?(Class)
+    end
+
+    describe 'with a belongs_to relationship method' do
+      before :all do
+        rescue_if 'Model#method_missing should delegate to relationships', @articles.kind_of?(Class) do
+          @articles.create(:content => 'Another Article', :original => @original)
+
+          @return = @collection = @articles.originals
+        end
+      end
+
+      should_not_be_a_kicker
+
+      it 'should return a Collection' do
+        @return.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should return expected Collection' do
+        @collection.should == [ @original ]
+      end
+
+      it 'should set the association for each Resource' do
+        @articles.map { |resource| resource.original }.should == [ @original, @original ]
+      end
+    end
+
+    describe 'with a has 1 relationship method' do
+      before :all do
+        # FIXME: create is necessary for m:m so that the intermediary
+        # is created properly.  This does not occur with @new.save
+        @new = @articles.send(@many_to_many ? :create : :new)
+
+        @article.previous = @new
+        @new.previous     = @other
+
+        @article.save
+        @new.save
+      end
+
+      describe 'with no arguments' do
+        before :all do
+          @return = @articles.previous
+        end
+
+        should_not_be_a_kicker
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return expected Collection' do
+          # association is sorted reverse by id
+          @return.should == [ @new, @other ]
+        end
+
+        it 'should set the association for each Resource' do
+          @articles.map { |resource| resource.previous }.should == [ @new, @other ]
+        end
+      end
+
+      describe 'with arguments' do
+        before :all do
+          @return = @articles.previous(:fields => [ :id ])
+        end
+
+        should_not_be_a_kicker
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return expected Collection' do
+          # association is sorted reverse by id
+          @return.should == [ @new, @other ]
+        end
+
+        { :id => true, :title => false, :content => false }.each do |attribute, expected|
+          it "should have query field #{attribute.inspect} #{'not' unless expected} loaded".squeeze(' ') do
+            @return.each { |resource| resource.attribute_loaded?(attribute).should == expected }
+          end
+        end
+
+        it 'should set the association for each Resource' do
+          @articles.map { |resource| resource.previous }.should == [ @new, @other ]
+        end
+      end
+    end
+
+    describe 'with a has n relationship method' do
+      before :all do
+        # FIXME: create is necessary for m:m so that the intermediary
+        # is created properly.  This does not occur with @new.save
+        @new = @articles.send(@many_to_many ? :create : :new)
+
+        # associate the article with children
+        @article.revisions << @new
+        @new.revisions     << @other
+
+        @article.save
+        @new.save
+      end
+
+      describe 'with no arguments' do
+        before :all do
+          @return = @collection = @articles.revisions
+        end
+
+        should_not_be_a_kicker
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return expected Collection' do
+          @collection.should == [ @other, @new ]
+        end
+
+        it 'should set the association for each Resource' do
+          @articles.map { |resource| resource.revisions }.should == [ [ @new ], [ @other ] ]
+        end
+      end
+
+      describe 'with arguments' do
+        before :all do
+          @return = @collection = @articles.revisions(:fields => [ :id ])
+        end
+
+        should_not_be_a_kicker
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return expected Collection' do
+          @collection.should == [ @other, @new ]
+        end
+
+        { :id => true, :title => false, :content => false }.each do |attribute, expected|
+          it "should have query field #{attribute.inspect} #{'not' unless expected} loaded".squeeze(' ') do
+            @collection.each { |resource| resource.attribute_loaded?(attribute).should == expected }
+          end
+        end
+
+        it 'should set the association for each Resource' do
+          @articles.map { |resource| resource.revisions }.should == [ [ @new ], [ @other ] ]
+        end
+      end
+    end
+
+    describe 'with a has n :through relationship method' do
+      before :all do
+        @new = @articles.create
+
+        @publication1 = @article.publications.create(:name => 'Ruby Today')
+        @publication2 = @new.publications.create(:name => 'Inside DataMapper')
+      end
+
+      describe 'with no arguments' do
+        before :all do
+          @return = @collection = @articles.publications
+        end
+
+        should_not_be_a_kicker
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return expected Collection' do
+          pending_if @no_join do
+            @collection.should == [ @publication1, @publication2 ]
+          end
+        end
+
+        it 'should set the association for each Resource' do
+          pending_if @no_join do
+            @articles.map { |resource| resource.publications }.should == [ [ @publication1 ], [ @publication2 ] ]
+          end
+        end
+      end
+
+      describe 'with arguments' do
+        before :all do
+          @return = @collection = @articles.publications(:fields => [ :id ])
+        end
+
+        should_not_be_a_kicker
+
+        it 'should return a Collection' do
+          @return.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return expected Collection' do
+          pending_if @no_join do
+            @collection.should == [ @publication1, @publication2 ]
+          end
+        end
+
+        { :id => true, :name => false }.each do |attribute, expected|
+          it "should have query field #{attribute.inspect} #{'not' unless expected} loaded".squeeze(' ') do
+            @collection.each { |resource| resource.attribute_loaded?(attribute).should == expected }
+          end
+        end
+
+        it 'should set the association for each Resource' do
+          pending_if @no_join do
+            @articles.map { |resource| resource.publications }.should == [ [ @publication1 ], [ @publication2 ] ]
+          end
+        end
+      end
+    end
+
+    describe 'with an unknown method' do
+      it 'should raise an exception' do
+        lambda {
+          @articles.unknown
+        }.should raise_error(NoMethodError)
+      end
+    end
+  end
+end