dm-core 0.9.11 → 0.10.0

data/spec/integration/property_spec.rb

@@ -1,253 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-# if RUBY_VERSION >= '1.9.0'
-#   require 'csv'
-# else
-#   gem 'fastercsv', '~>1.4.0'
-#   require 'fastercsv'
-# end
-
-describe DataMapper::Property do
-  before do
-    module ::PropertySpec
-      class Resource
-        include DataMapper::Resource
-      end
-    end
-
-    @property = PropertySpec::Resource.property :id, DM::Serial
-  end
-
-  it 'should be serializable with Marshal' do
-    Marshal.load(Marshal.dump(@property)).should == @property
-  end
-end
-
-if ADAPTER
-  describe DataMapper::Property, "with #{ADAPTER}" do
-    describe " tracking strategies" do
-      before :all do
-        class ::Actor
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :name, String, :track => :set # :track default is :get for mutable types
-          property :notes, DataMapper::Types::Text
-          property :age, Integer # :track default is :set for immutable types
-          property :rating, Integer
-          property :location, String
-          property :lead, TrueClass, :track => :load
-          property :cv, Object # :track should be :hash
-          property :agent, String, :track => :hash # :track only Object#hash value on :load.
-            # Potentially faster, but less safe, so use judiciously, when the odds of a hash-collision are low.
-        end
-      end
-
-      before do
-        Actor.auto_migrate!(ADAPTER)
-      end
-
-      it "should set up tracking information" do
-        Actor.properties[:name].track.should == :set
-        Actor.properties[:location].track.should == :get
-        Actor.properties[:rating].track.should == :set
-        Actor.properties[:lead].track.should == :load
-        Actor.properties[:cv].track.should == :hash
-        Actor.properties[:agent].track.should == :hash
-      end
-
-      it "should track on :set" do
-        repository(ADAPTER) do
-          bob = Actor.new(:name => 'bob')
-          bob.save
-
-          bob.original_values.should_not have_key(:name)
-          bob.dirty?.should == false
-
-          bob.name = "Bob"
-          bob.original_values.should have_key(:name)
-          bob.original_values[:name].should == 'bob'
-          bob.dirty?.should == true
-        end
-      end
-
-      it "should track on :get" do
-        repository(ADAPTER) do
-          jon = Actor.new(:name => 'jon', :location => 'dallas')
-          jon.save
-
-          jon.location
-          jon.original_values.should have_key(:location)
-          jon.original_values[:location].should == 'dallas'
-
-          jon.dirty?.should be_false
-          jon.save.should be_true
-
-          jon.location.upcase!
-          jon.location.should == 'DALLAS'
-          jon.original_values[:location].should == 'dallas'
-
-          jon.dirty?.should be_true
-          jon.save.should be_true
-
-          jon.location << '!'
-          jon.original_values[:location].should == 'DALLAS'
-          jon.dirty?.should be_true
-        end
-      end
-
-      it "should track on :load" do
-        repository(ADAPTER) do
-          jan = Actor.create(:name => 'jan', :lead => true)
-          jan.lead = false
-          jan.original_values[:lead].should be_true
-          jan.dirty?.should == true
-        end
-        repository(ADAPTER) do
-          jan = Actor.first
-          jan.original_values.should have_key(:lead)
-          jan.original_values[:lead].should be_true
-          jan.dirty?.should == false
-        end
-      end
-
-      it "should track on :hash" do
-        cv = { 2005 => "Othello" }
-        repository(ADAPTER) do
-          tom = Actor.create(:name => 'tom', :cv => cv)
-        end
-        repository(ADAPTER) do
-          tom = Actor.first(:name => 'tom')
-          tom.cv.merge!({2006 => "Macbeth"})
-
-          tom.original_values.should have_key(:cv)
-          # tom.original_values[:cv].should == cv.hash
-          tom.cv.should == { 2005 => "Othello", 2006 => "Macbeth" }
-          tom.dirty?.should == true
-        end
-      end
-
-      it "should track with lazy text fields (#342)" do
-        repository(ADAPTER) do
-          tim = Actor.create(:name => 'tim')
-        end
-        repository(ADAPTER) do
-          tim = Actor.first(:name => 'tim')
-          tim.notes # make sure they're loaded...
-          tim.dirty?.should be_false
-          tim.save.should be_true
-          tim.notes = "Testing"
-          tim.dirty?.should be_true
-          tim.save.should be_true
-        end
-        repository(ADAPTER) do
-          tim = Actor.first(:name => 'tim')
-          tim.notes.should == "Testing"
-        end
-      end
-    end
-
-    describe "lazy loading" do
-      before :all do
-        class ::RowBoat
-          include DataMapper::Resource
-          property :id, Serial
-          property :notes, String, :lazy => [:notes]
-          property :trip_report, String, :lazy => [:notes,:trip]
-          property :miles, Integer, :lazy => [:trip]
-        end
-      end
-
-      before do
-        RowBoat.auto_migrate!(ADAPTER)
-
-        repository(ADAPTER) do
-          RowBoat.create(:id => 1, :notes=>'Note',:trip_report=>'Report',:miles=>23)
-          RowBoat.create(:id => 2, :notes=>'Note',:trip_report=>'Report',:miles=>23)
-          RowBoat.create(:id => 3, :notes=>'Note',:trip_report=>'Report',:miles=>23)
-        end
-      end
-
-      it "should lazy load in context" do
-        result = repository(ADAPTER) { RowBoat.all.to_a }
-
-        result[0].attribute_loaded?(:notes).should be_false
-        result[0].attribute_loaded?(:trip_report).should be_false
-        result[1].attribute_loaded?(:notes).should be_false
-
-        result[0].notes.should_not be_nil
-
-        result[1].attribute_loaded?(:notes).should be_true
-        result[1].attribute_loaded?(:trip_report).should be_true
-        result[1].attribute_loaded?(:miles).should be_false
-
-        result = repository(ADAPTER) { RowBoat.all.to_a }
-
-        result[0].attribute_loaded?(:trip_report).should be_false
-        result[0].attribute_loaded?(:miles).should be_false
-
-        result[1].trip_report.should_not be_nil
-        result[2].attribute_loaded?(:miles).should be_true
-      end
-
-      it "should lazy load on Property#set" do
-        repository(ADAPTER) do
-          boat = RowBoat.first
-          boat.attribute_loaded?(:notes).should be_false
-          boat.notes = 'New Note'
-          boat.original_values[:notes].should == "Note"
-        end
-      end
-    end
-
-    describe 'defaults' do
-      before :all do
-        class ::Catamaran
-          include DataMapper::Resource
-          property :id, Serial
-          property :name, String
-
-          # Boolean
-          property :could_be_bool0, TrueClass, :default => true
-          property :could_be_bool1, TrueClass, :default => false
-        end
-
-        repository(ADAPTER){ Catamaran.auto_migrate!(ADAPTER) }
-      end
-
-      before :each do
-        @cat = Catamaran.new
-      end
-
-      it "should have defaults" do
-        @cat.could_be_bool0.should == true
-        @cat.could_be_bool1.should_not be_nil
-        @cat.could_be_bool1.should == false
-
-        @cat.name = 'Mary Mayweather'
-
-        repository(ADAPTER) do
-          @cat.save
-
-          cat = Catamaran.first
-          cat.could_be_bool0.should == true
-          cat.could_be_bool1.should_not be_nil
-          cat.could_be_bool1.should == false
-          cat.destroy
-        end
-
-      end
-
-      it "should have defaults even with creates" do
-        repository(ADAPTER) do
-          Catamaran.create(:name => 'Jingle All The Way')
-          cat = Catamaran.first
-          cat.name.should == 'Jingle All The Way'
-          cat.could_be_bool0.should == true
-          cat.could_be_bool1.should_not be_nil
-          cat.could_be_bool1.should == false
-        end
-      end
-    end
-  end
-end

data/spec/integration/query_spec.rb

@@ -1,514 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-if ADAPTER
-  module QuerySpec
-    class SailBoat
-      include DataMapper::Resource
-
-      property :id,      Serial
-      property :name,    String
-      property :port,    String
-      property :captain, String
-
-      def self.default_repository_name
-        ADAPTER
-      end
-    end
-
-    class Permission
-      include DataMapper::Resource
-
-      property :id,            Serial
-      property :user_id,       Integer
-      property :resource_id,   Integer
-      property :resource_type, String
-      property :token,         String
-
-      def self.default_repository_name
-        ADAPTER
-      end
-    end
-
-    class Region
-      include DataMapper::Resource
-
-      property :id,   Serial
-      property :name, String
-   property :type, String
-
-      def self.default_repository_name
-        ADAPTER
-      end
-    end
-
-    class Factory
-      include DataMapper::Resource
-
-      property :id,        Serial
-      property :region_id, Integer
-      property :name,      String
-
-      repository(:mock) do
-        property :land, String
-      end
-
-      belongs_to :region
-
-      def self.default_repository_name
-        ADAPTER
-      end
-    end
-
-    class Vehicle
-      include DataMapper::Resource
-
-      property :id,         Serial
-      property :factory_id, Integer
-      property :name,       String
-
-      belongs_to :factory
-
-      def self.default_repository_name
-        ADAPTER
-      end
-    end
-
-    class Group
-      include DataMapper::Resource
-      property :id, Serial
-      property :name, String
-    end
-  end
-
-  module Namespace
-    class Region
-      include DataMapper::Resource
-
-      property :id,   Serial
-      property :name, String
-
-      def self.default_repository_name
-        ADAPTER
-      end
-    end
-
-    class Factory
-      include DataMapper::Resource
-
-      property :id,        Serial
-      property :region_id, Integer
-      property :name,      String
-
-      repository(:mock) do
-        property :land, String
-      end
-
-      belongs_to :region
-
-      def self.default_repository_name
-        ADAPTER
-      end
-    end
-
-    class Vehicle
-      include DataMapper::Resource
-      property :id,         Serial
-      property :factory_id, Integer
-      property :name,       String
-
-      belongs_to :factory
-
-      def self.default_repository_name
-        ADAPTER
-      end
-    end
-  end
-
-  describe DataMapper::Query, "with #{ADAPTER}" do
-    before do
-      @query = DataMapper::Query.new(repository(ADAPTER), QuerySpec::SailBoat)
-    end
-
-    it 'should be serializable with Marshal' do
-      Marshal.load(Marshal.dump(@query)).should == @query
-    end
-
-    describe '#unique' do
-      include LoggingHelper
-
-      before(:each) do
-        QuerySpec::SailBoat.auto_migrate!
-
-        QuerySpec::SailBoat.create(:name => 'A', :port => 'C')
-        QuerySpec::SailBoat.create(:name => 'B', :port => 'B')
-        QuerySpec::SailBoat.create(:name => 'C', :port => 'A')
-      end
-
-      def parse_statement(log)
-        log.readlines.join.chomp.split(' ~ ').last.sub(/\A\(\d+\.\d+\)\s+/, '')
-      end
-
-      describe 'when true' do
-        if [ :postgres, :sqlite3, :mysql ].include?(ADAPTER)
-          it 'should add a GROUP BY to the SQL query' do
-            logger do |log|
-              QuerySpec::SailBoat.all(:unique => true, :fields => [ :id ]).to_a
-
-              case ADAPTER
-                when :postgres, :sqlite3
-                  parse_statement(log).should == 'SELECT "id" FROM "query_spec_sail_boats" GROUP BY "id" ORDER BY "id"'
-                when :mysql
-                  parse_statement(log).should == 'SELECT `id` FROM `query_spec_sail_boats` GROUP BY `id` ORDER BY `id`'
-              end
-            end
-          end
-
-          it 'should not add a GROUP BY to the SQL query if no field is a Property' do
-            operator = DataMapper::Query::Operator.new(:thing, :test)
-
-            # make the operator act like a Property
-            class << operator
-              property = QuerySpec::SailBoat.properties[:id]
-              (property.methods - (public_instance_methods - %w[ type ])).each do |method|
-                define_method(method) do |*args|
-                  property.send(method, *args)
-                end
-              end
-            end
-
-            operator.should_not be_kind_of(DataMapper::Property)
-
-            logger do |log|
-              QuerySpec::SailBoat.all(:unique => true, :fields => [ operator ]).to_a
-
-              case ADAPTER
-                when :postgres, :sqlite3
-                  parse_statement(log).should == 'SELECT "id" FROM "query_spec_sail_boats" ORDER BY "id"'
-                when :mysql
-                  parse_statement(log).should == 'SELECT `id` FROM `query_spec_sail_boats` ORDER BY `id`'
-              end
-            end
-          end
-        end
-      end
-
-      describe 'when false' do
-        if [ :postgres, :sqlite3, :mysql ].include?(ADAPTER)
-          it 'should not add a GROUP BY to the SQL query' do
-            logger do |log|
-              QuerySpec::SailBoat.all(:unique => false, :fields => [ :id ]).to_a
-
-              case ADAPTER
-                when :postgres, :sqlite3
-                  parse_statement(log).should == 'SELECT "id" FROM "query_spec_sail_boats" ORDER BY "id"'
-                when :mysql
-                  parse_statement(log).should == 'SELECT `id` FROM `query_spec_sail_boats` ORDER BY `id`'
-              end
-            end
-          end
-        end
-      end
-    end
-
-    describe 'when ordering' do
-      before(:each) do
-        QuerySpec::SailBoat.auto_migrate!
-
-        QuerySpec::SailBoat.create(:name => 'A', :port => 'C')
-        QuerySpec::SailBoat.create(:name => 'B', :port => 'B')
-        QuerySpec::SailBoat.create(:name => 'C', :port => 'A')
-      end
-
-      it "should find by conditions" do
-        lambda do
-          repository(ADAPTER) do
-            QuerySpec::SailBoat.first(:conditions => [ 'name = ?', 'B' ])
-          end
-        end.should_not raise_error
-
-        lambda do
-          repository(ADAPTER) do
-            QuerySpec::SailBoat.first(:conditions => [ 'name = ?', 'A' ])
-          end
-        end.should_not raise_error
-      end
-
-      it "should find by conditions passed in as hash" do
-        repository(ADAPTER) do
-          QuerySpec::SailBoat.create(:name => "couldbe@email.com", :port => 'wee')
-
-          find = QuerySpec::SailBoat.first(:name => 'couldbe@email.com')
-          find.name.should == 'couldbe@email.com'
-
-          find = QuerySpec::SailBoat.first(:name => 'couldbe@email.com', :port.not => nil)
-          find.should_not be_nil
-          find.port.should_not be_nil
-          find.name.should == 'couldbe@email.com'
-        end
-      end
-
-      it "should find by conditions passed in a range" do
-        repository(ADAPTER) do
-          find = QuerySpec::SailBoat.all(:id => 0..2)
-          find.should_not be_nil
-          find.should have(2).entries
-
-          find = QuerySpec::SailBoat.all(:id.not => 0..2)
-          find.should have(1).entries
-        end
-      end
-
-      it "should find by conditions passed in as an array" do
-        repository(ADAPTER) do
-          find = QuerySpec::SailBoat.all(:id => [1,2])
-          find.should_not be_nil
-          find.should have(2).entries
-
-          find = QuerySpec::SailBoat.all(:id.not => [1,2])
-          find.should have(1).entries
-        end
-      end
-
-      describe "conditions passed in as an empty array" do
-        it "should work when id is an empty Array" do
-          repository(ADAPTER) do
-            find = QuerySpec::SailBoat.all(:id => [])
-            find.should have(0).entries
-          end
-        end
-
-        it "should work when id is NOT an empty Array" do
-          repository(ADAPTER) do
-            find = QuerySpec::SailBoat.all(:id.not => [])
-            find.should have(3).entries
-          end
-        end
-
-        it "should work when id is an empty Array and other conditions are specified" do
-          repository(ADAPTER) do
-            find = QuerySpec::SailBoat.all(:id => [], :name => "A")
-            find.should have(0).entries
-          end
-        end
-
-        it "should work when id is NOT an empty Array and other conditions are specified" do
-          repository(ADAPTER) do
-            find = QuerySpec::SailBoat.all(:id.not => [], :name => "A")
-            find.should have(1).entries
-          end
-        end
-
-        it "should work when id is NOT an empty Array and other Array conditions are specified" do
-          repository(ADAPTER) do
-            find = QuerySpec::SailBoat.all(:id.not => [], :name => ["A", "B"])
-            find.should have(2).entries
-          end
-        end
-      end
-
-      it "should order results" do
-        repository(ADAPTER) do
-          result = QuerySpec::SailBoat.all(:order => [
-            DataMapper::Query::Direction.new(QuerySpec::SailBoat.properties[:name], :asc)
-          ])
-          result[0].id.should == 1
-
-          result = QuerySpec::SailBoat.all(:order => [
-            DataMapper::Query::Direction.new(QuerySpec::SailBoat.properties[:port], :asc)
-          ])
-          result[0].id.should == 3
-
-          result = QuerySpec::SailBoat.all(:order => [
-            DataMapper::Query::Direction.new(QuerySpec::SailBoat.properties[:name], :asc),
-            DataMapper::Query::Direction.new(QuerySpec::SailBoat.properties[:port], :asc)
-          ])
-          result[0].id.should == 1
-
-          result = QuerySpec::SailBoat.all(:order => [
-            QuerySpec::SailBoat.properties[:name],
-            DataMapper::Query::Direction.new(QuerySpec::SailBoat.properties[:port], :asc)
-          ])
-          result[0].id.should == 1
-
-          result = QuerySpec::SailBoat.all(:order => [ :name ])
-          result[0].id.should == 1
-
-          result = QuerySpec::SailBoat.all(:order => [ :name.desc ])
-          result[0].id.should == 3
-        end
-      end
-    end
-
-    describe 'when sub-selecting' do
-      before(:each) do
-        [ QuerySpec::SailBoat, QuerySpec::Permission ].each { |m| m.auto_migrate! }
-
-        QuerySpec::SailBoat.create(:id => 1, :name => "Fantasy I",      :port => "Cape Town", :captain => 'Joe')
-        QuerySpec::SailBoat.create(:id => 2, :name => "Royal Flush II", :port => "Cape Town", :captain => 'James')
-        QuerySpec::SailBoat.create(:id => 3, :name => "Infringer III",  :port => "Cape Town", :captain => 'Jason')
-
-        #User 1 permission -- read boat 1 & 2
-        QuerySpec::Permission.create(:id => 1, :user_id => 1, :resource_id => 1, :resource_type => 'SailBoat', :token => 'READ')
-        QuerySpec::Permission.create(:id => 2, :user_id => 1, :resource_id => 2, :resource_type => 'SailBoat', :token => 'READ')
-
-        #User 2 permission  -- read boat 2 & 3
-        QuerySpec::Permission.create(:id => 3, :user_id => 2, :resource_id => 2, :resource_type => 'SailBoat', :token => 'READ')
-        QuerySpec::Permission.create(:id => 4, :user_id => 2, :resource_id => 3, :resource_type => 'SailBoat', :token => 'READ')
-      end
-
-      it 'should accept a DM::Query as a value of a condition' do
-        # User 1
-        acl = DataMapper::Query.new(repository(ADAPTER), QuerySpec::Permission, :user_id => 1, :resource_type => 'SailBoat', :token => 'READ', :fields => [ :resource_id ])
-        query = { :port => 'Cape Town', :id => acl, :captain.like => 'J%', :order => [ :id ] }
-        boats = repository(ADAPTER) { QuerySpec::SailBoat.all(query) }
-        boats.should have(2).entries
-        boats.entries[0].id.should == 1
-        boats.entries[1].id.should == 2
-
-        # User 2
-        acl = DataMapper::Query.new(repository(ADAPTER), QuerySpec::Permission, :user_id => 2, :resource_type => 'SailBoat', :token => 'READ', :fields => [ :resource_id ])
-        query = { :port => 'Cape Town', :id => acl, :captain.like => 'J%', :order => [ :id ] }
-        boats = repository(ADAPTER) { QuerySpec::SailBoat.all(query) }
-
-        boats.should have(2).entries
-        boats.entries[0].id.should == 2
-        boats.entries[1].id.should == 3
-      end
-
-      it 'when value is NOT IN another query' do
-        # Boats that User 1 Cannot see
-        acl = DataMapper::Query.new(repository(ADAPTER), QuerySpec::Permission, :user_id => 1, :resource_type => 'SailBoat', :token => 'READ', :fields => [ :resource_id ])
-        query = { :port => 'Cape Town', :id.not => acl, :captain.like => 'J%' }
-        boats = repository(ADAPTER) { QuerySpec::SailBoat.all(query) }
-        boats.should have(1).entries
-        boats.entries[0].id.should == 3
-      end
-    end  # describe sub-selecting
-
-    describe 'when linking associated objects' do
-      before(:each) do
-        [ QuerySpec::Region, QuerySpec::Factory, QuerySpec::Vehicle ].each { |m| m.auto_migrate! }
-
-        QuerySpec::Region.create(:id => 1, :name => 'North West', :type => 'commercial')
-        QuerySpec::Factory.create(:id => 2000, :region_id => 1, :name => 'North West Plant')
-        QuerySpec::Vehicle.create(:id => 1, :factory_id => 2000, :name => '10 ton delivery truck')
-
-        Namespace::Region.auto_migrate!
-        Namespace::Factory.auto_migrate!
-        Namespace::Vehicle.auto_migrate!
-
-        Namespace::Region.create(:id => 1, :name => 'North West')
-        Namespace::Factory.create(:id => 2000, :region_id => 1, :name => 'North West Plant')
-        Namespace::Vehicle.create(:id => 1, :factory_id => 2000, :name => '10 ton delivery truck')
-      end
-
-      it 'should require that all properties in :fields and all :links come from the same repository' #do
-      #  land = QuerySpec::Factory.properties(:mock)[:land]
-      #  fields = []
-      #  QuerySpec::Vehicle.properties(ADAPTER).map do |property|
-      #    fields << property
-      #  end
-      #  fields << land
-      #
-      #  lambda{
-      #    begin
-      #      results = repository(ADAPTER) { QuerySpec::Vehicle.all(:links => [ :factory ], :fields => fields) }
-      #    rescue RuntimeError
-      #      $!.message.should == "Property QuerySpec::Factory.land not available in repository #{ADAPTER}"
-      #      raise $!
-      #    end
-      #  }.should raise_error(RuntimeError)
-      #end
-
-      it 'should accept a DM::Assoc::Relationship as a link' do
-        factory = DataMapper::Associations::Relationship.new(
-          :factory,
-          ADAPTER,
-          QuerySpec::Vehicle,
-          QuerySpec::Factory,
-          { :child_key => [ :factory_id ], :parent_key => [ :id ] }
-        )
-        results = repository(ADAPTER) { QuerySpec::Vehicle.all(:links => [ factory ]) }
-        results.should have(1).entries
-      end
-
-      it 'should accept a symbol of an association name as a link' do
-        results = repository(ADAPTER) { QuerySpec::Vehicle.all(:links => [ :factory ]) }
-        results.should have(1).entries
-      end
-
-      it 'should accept a string of an association name as a link' do
-        results = repository(ADAPTER) { QuerySpec::Vehicle.all(:links => [ 'factory' ]) }
-        results.should have(1).entries
-      end
-
-      it 'should accept a mixture of items as a set of links' do
-        region = DataMapper::Associations::Relationship.new(
-          :region,
-          ADAPTER,
-          QuerySpec::Factory,
-          QuerySpec::Region,
-          { :child_key => [ :region_id ], :parent_key => [ :id ] }
-        )
-        results = repository(ADAPTER) { QuerySpec::Vehicle.all(:links => [ 'factory', region ]) }
-        results.should have(1).entries
-      end
-
-      it 'should only accept a DM::Assoc::Relationship, String & Symbol as a link' do
-        lambda{
-          DataMapper::Query.new(repository(ADAPTER), QuerySpec::Vehicle, :links => [1])
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'should have a association by the name of the Symbol or String' do
-        lambda{
-          DataMapper::Query.new(repository(ADAPTER), QuerySpec::Vehicle, :links => [ 'Sailing' ])
-        }.should raise_error(ArgumentError)
-
-        lambda{
-          DataMapper::Query.new(repository(ADAPTER), QuerySpec::Vehicle, :links => [ :sailing ])
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'should create an n-level query path' do
-        QuerySpec::Vehicle.factory.region.model.should == QuerySpec::Region
-        QuerySpec::Vehicle.factory.region.name.property.should == QuerySpec::Region.properties(QuerySpec::Region.repository.name)[ :name ]
-      end
-
-      it 'should accept a DM::QueryPath as the key to a condition' do
-        vehicle = QuerySpec::Vehicle.first(QuerySpec::Vehicle.factory.region.name => 'North West')
-        vehicle.name.should == '10 ton delivery truck'
-
-        vehicle = Namespace::Vehicle.first(Namespace::Vehicle.factory.region.name => 'North West')
-        vehicle.name.should == '10 ton delivery truck'
-      end
-
-      it "should accept a string representing a DM::QueryPath as they key to a condition" do
-        vehicle = QuerySpec::Vehicle.first("factory.region.name" => 'North West')
-        vehicle.name.should == '10 ton delivery truck'
-      end
-
-   it "should accept 'id' and 'type' as endpoints on ah DM::QueryPath" do
-    vehicle = QuerySpec::Vehicle.first( QuerySpec::Vehicle.factory.region.type => 'commercial' )
-    vehicle.name.should == '10 ton delivery truck'
-    vehicle = QuerySpec::Vehicle.first( QuerySpec::Vehicle.factory.region.id => 1 )
-    vehicle.name.should == '10 ton delivery truck'
-   end
-
-      it 'should auto generate the link if a DM::Property from a different resource is in the :fields option'
-
-      it 'should create links with composite keys'
-
-      it 'should eager load associations' do
-        repository(ADAPTER) do
-          vehicle = QuerySpec::Vehicle.first(:includes => [ QuerySpec::Vehicle.factory ])
-        end
-      end
-
-      it "should behave when using mocks" do
-        QuerySpec::Group.should_receive(:all).with(:order => [ :id.asc ])
-        QuerySpec::Group.all(:order => [ :id.asc ])
-      end
-    end   # describe links
-  end # DM::Query
-end