dm-core 0.9.2 → 0.9.3

data/spec/integration/dependency_queue_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe "DataMapper::DependencyQueue" do
+  before :each do
+    @q = DataMapper::DependencyQueue.new
+    @dependencies = @q.instance_variable_get("@dependencies")
+  end
+
+  describe "#initialize" do
+    describe "@dependencies" do
+      it "should be a hash after initialize" do
+        @dependencies.should be_a_kind_of(Hash)
+      end
+
+      it "should set value to [] when new key is accessed" do
+        @dependencies['New Key'].should == []
+      end
+    end
+  end
+
+  describe "#add" do
+    it "should store the supplied callback in @dependencies" do
+      @q.add('MissingConstant') { true }
+      @dependencies['MissingConstant'].first.call.should == true
+    end
+  end
+
+  describe "#resolve!" do
+    describe "(when dependency is not defined)" do
+      it "should not alter @dependencies" do
+        @q.add('MissingConstant') { true }
+        old_dependencies = @dependencies.dup
+        @q.resolve!
+        old_dependencies.should == @dependencies
+      end
+    end
+
+    describe "(when dependency is defined)" do
+      before :each do
+        @q.add('MissingConstant') { |klass| klass.instance_variable_set("@resolved", true) } # add before MissingConstant is loaded
+
+        class MissingConstant
+        end
+      end
+
+      it "should execute stored callbacks" do
+        @q.resolve!
+        MissingConstant.instance_variable_get("@resolved").should == true
+      end
+
+      it "should clear @dependencies" do
+        @q.resolve!
+        @dependencies['MissingConstant'].should be_empty
+      end
+    end
+  end
+
+end

data/spec/integration/model_spec.rb

@@ -13,6 +13,9 @@ if ADAPTER
       property :name, String
       property :type, Discriminator
     end
+
+    class STIDescendant < STI
+    end
   end
 
   describe "DataMapper::Model with #{ADAPTER}" do
@@ -20,18 +23,29 @@ if ADAPTER
       repository(ADAPTER) do
         ModelSpec::STI.auto_migrate!
       end
-    end
 
-    describe '.new' do
-      before :all do
-        @planet = DataMapper::Model.new('planet') do
-          property :name, String, :key => true
-          property :distance, Integer
-        end
+      @planet = DataMapper::Model.new('planet') do
+        def self.default_repository_name; ADAPTER end
+        property :name, String, :key => true
+        property :distance, Integer
+      end
 
-        @planet.auto_migrate!(ADAPTER)
+      @moon   = DataMapper::Model.new('moon') do
+        def self.default_repository_name; ADAPTER end
+        property :id, DM::Serial
+        property :name, String
       end
 
+      @planet.auto_migrate!(ADAPTER)
+      @moon.auto_migrate!(ADAPTER)
+
+      repository(ADAPTER) do
+        @moon.create(:name => "Charon")
+        @moon.create(:name => "Phobos")
+      end
+    end
+
+    describe '.new' do
       it 'should be able to persist' do
         repository(ADAPTER) do
           pluto = @planet.new
@@ -46,6 +60,51 @@ if ADAPTER
       end
     end
 
+    describe ".get" do
+      include LoggingHelper
+
+      it "should typecast key" do
+        resource = nil
+        lambda {
+          repository(ADAPTER) do
+            resource = @moon.get("1")
+          end
+        }.should_not raise_error
+        resource.should be_kind_of(DataMapper::Resource)
+      end
+
+      it "should use the identity map within a repository block" do
+        logger do |log|
+          repository(ADAPTER) do
+            @moon.get("1")
+            @moon.get(1)
+          end
+          log.readlines.size.should == 1
+        end
+      end
+
+      it "should not use the identity map outside a repository block" do
+        logger do |log|
+          @moon.get(1)
+          @moon.get(1)
+          log.readlines.size.should == 2
+        end
+      end
+    end
+
+    describe ".base_model" do
+      describe "(when called on base model)" do
+        it "should refer to itself" do
+          ModelSpec::STI.base_model.should == ModelSpec::STI
+        end
+      end
+      describe "(when called on descendant model)" do
+        it "should refer to the base model" do
+          ModelSpec::STIDescendant.base_model.should == ModelSpec::STI.base_model
+        end
+      end
+    end
+
     it 'should provide #load' do
       ModelSpec::STI.should respond_to(:load)
     end

data/spec/integration/postgres_adapter_spec.rb

@@ -146,7 +146,7 @@ if HAS_POSTGRES
         pending "This works, but no create-schema support in PostgresAdapter to easily test with"
         lambda do
           repository(:postgres) do
-            Voyager.create!(:age => 1_000)
+            Voyager.create(:age => 1_000)
           end
         end.should_not raise_error
       end
@@ -388,9 +388,9 @@ if HAS_POSTGRES
         SailBoat.auto_migrate!(:postgres)
 
         repository(:postgres) do
-          SailBoat.create!(:id => 1, :name => "A", :port => "C")
-          SailBoat.create!(:id => 2, :name => "B", :port => "B")
-          SailBoat.create!(:id => 3, :name => "C", :port => "A")
+          SailBoat.create(:id => 1, :name => "A", :port => "C")
+          SailBoat.create(:id => 2, :name => "B", :port => "B")
+          SailBoat.create(:id => 3, :name => "C", :port => "A")
         end
       end
 
@@ -436,9 +436,9 @@ if HAS_POSTGRES
         SailBoat.auto_migrate!(:postgres)
 
         repository(:postgres) do
-          SailBoat.create!(:id => 1, :notes=>'Note',:trip_report=>'Report',:miles=>23)
-          SailBoat.create!(:id => 2, :notes=>'Note',:trip_report=>'Report',:miles=>23)
-          SailBoat.create!(:id => 3, :notes=>'Note',:trip_report=>'Report',:miles=>23)
+          SailBoat.create(:id => 1, :notes=>'Note',:trip_report=>'Report',:miles=>23)
+          SailBoat.create(:id => 2, :notes=>'Note',:trip_report=>'Report',:miles=>23)
+          SailBoat.create(:id => 3, :notes=>'Note',:trip_report=>'Report',:miles=>23)
         end
       end
 
@@ -480,7 +480,7 @@ if HAS_POSTGRES
 
         repository(:postgres) do
           100.times do
-            SerialFinderSpec.create!(:sample => rand.to_s)
+            SerialFinderSpec.create(:sample => rand.to_s)
           end
         end
       end
@@ -507,8 +507,9 @@ if HAS_POSTGRES
         sfs.should be_a_kind_of(SerialFinderSpec)
         sfs.should_not be_a_new_record
 
-        sfs.instance_variables.should_not include('@sample')
-        sfs.sample.should_not be_nil
+        sfs.attribute_loaded?(:sample).should be_false
+        sfs.sample
+        sfs.attribute_loaded?(:sample).should be_true
       end
 
       it "should translate an Array to an IN clause" do
@@ -529,6 +530,7 @@ if HAS_POSTGRES
       before :all do
         class Engine
           include DataMapper::Resource
+          def self.default_repository_name; :postgres end
 
           property :id, Serial
           property :name, String
@@ -536,14 +538,13 @@ if HAS_POSTGRES
 
         class Yard
           include DataMapper::Resource
+          def self.default_repository_name; :postgres end
 
           property :id, Serial
           property :name, String
           property :engine_id, Integer
 
-          repository(:postgres) do
-            belongs_to :engine
-          end
+          belongs_to :engine
         end
       end
 
@@ -591,7 +592,7 @@ if HAS_POSTGRES
       it 'should save the association key in the child' do
         repository(:postgres) do
           e = Engine.first(:id => 2)
-          Yard.create!(:id => 2, :name => 'yard2', :engine => e)
+          Yard.create(:id => 2, :name => 'yard2', :engine => e)
         end
 
         repository(:postgres) do
@@ -618,25 +619,23 @@ if HAS_POSTGRES
       before :all do
         class Host
           include DataMapper::Resource
+          def self.default_repository_name; :postgres end
 
           property :id, Serial
           property :name, String
 
-          repository(:postgres) do
-            has n, :slices
-          end
+          has n, :slices
         end
 
         class Slice
           include DataMapper::Resource
+          def self.default_repository_name; :postgres end
 
           property :id, Serial
           property :name, String
           property :host_id, Integer
 
-          repository(:postgres) do
-            belongs_to :host
-          end
+          belongs_to :host
         end
       end
 

data/spec/integration/property_spec.rb

@@ -13,7 +13,7 @@ if ADAPTER
           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 mutable types
+          property :age, Integer # :track default is :set for immutable types
           property :rating, Integer
           property :location, String
           property :lead, TrueClass, :track => :load
@@ -78,7 +78,7 @@ if ADAPTER
 
       it "should track on :load" do
         repository(ADAPTER) do
-          jan = Actor.create!(:name => 'jan', :lead => true)
+          jan = Actor.create(:name => 'jan', :lead => true)
           jan.lead = false
           jan.original_values[:lead].should be_true
           jan.dirty?.should == true
@@ -94,7 +94,7 @@ if ADAPTER
       it "should track on :hash" do
         cv = { 2005 => "Othello" }
         repository(ADAPTER) do
-          tom = Actor.create!(:name => 'tom', :cv => cv)
+          tom = Actor.create(:name => 'tom', :cv => cv)
         end
         repository(ADAPTER) do
           tom = Actor.first(:name => 'tom')
@@ -109,7 +109,7 @@ if ADAPTER
 
       it "should track with lazy text fields (#342)" do
         repository(ADAPTER) do
-          tim = Actor.create!(:name => 'tim')
+          tim = Actor.create(:name => 'tim')
         end
         repository(ADAPTER) do
           tim = Actor.first(:name => 'tim')
@@ -142,9 +142,9 @@ if ADAPTER
         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)
+          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
 
@@ -169,6 +169,15 @@ if ADAPTER
         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
@@ -211,7 +220,7 @@ if ADAPTER
 
       it "should have defaults even with creates" do
         repository(ADAPTER) do
-          Catamaran.create!(:name => 'Jingle All The Way')
+          Catamaran.create(:name => 'Jingle All The Way')
           cat = Catamaran.first
           cat.name.should == 'Jingle All The Way'
           cat.could_be_bool0.should == true

data/spec/integration/query_spec.rb

@@ -1,49 +1,238 @@
 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
-    describe 'when ordering' do
-      before :all do
-        class SailBoat
-          include DataMapper::Resource
-          property :id, Serial
-          property :name, String
-          property :port, String
+    describe '#unique' do
+      include LoggingHelper
+
+      before 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
+      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 do
-        SailBoat.auto_migrate!(ADAPTER)
+        QuerySpec::SailBoat.auto_migrate!
 
-        repository(ADAPTER) do
-          SailBoat.create!(:name => 'A', :port => 'C')
-          SailBoat.create!(:name => 'B', :port => 'B')
-          SailBoat.create!(:name => 'C', :port => 'A')
-        end
+        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
-            SailBoat.first(:conditions => ['name = ?', 'B'])
+            QuerySpec::SailBoat.first(:conditions => [ 'name = ?', 'B' ])
           end
         end.should_not raise_error
 
         lambda do
           repository(ADAPTER) do
-            SailBoat.first(:conditions => ['name = ?', 'A'])
+            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
-          SailBoat.create!(:name => "couldbe@email.com", :port => 'wee')
+          QuerySpec::SailBoat.create(:name => "couldbe@email.com", :port => 'wee')
 
-          find = SailBoat.first(:name => 'couldbe@email.com')
+          find = QuerySpec::SailBoat.first(:name => 'couldbe@email.com')
           find.name.should == 'couldbe@email.com'
 
-          find = SailBoat.first(:name => 'couldbe@email.com', :port.not => nil)
+          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'
@@ -52,100 +241,78 @@ if ADAPTER
 
       it "should find by conditions passed in a range" do
         repository(ADAPTER) do
-          find = SailBoat.all(:id => 0..2)
+          find = QuerySpec::SailBoat.all(:id => 0..2)
           find.should_not be_nil
           find.should have(2).entries
 
-          find = SailBoat.all(:id.not => 0..2)
+          find = QuerySpec::SailBoat.all(:id.not => 0..2)
           find.should have(1).entries
         end
       end
 
       it "should order results" do
         repository(ADAPTER) do
-          result = SailBoat.all(:order => [
-            DataMapper::Query::Direction.new(SailBoat.properties[:name], :asc)
+          result = QuerySpec::SailBoat.all(:order => [
+            DataMapper::Query::Direction.new(QuerySpec::SailBoat.properties[:name], :asc)
           ])
           result[0].id.should == 1
 
-          result = SailBoat.all(:order => [
-            DataMapper::Query::Direction.new(SailBoat.properties[:port], :asc)
+          result = QuerySpec::SailBoat.all(:order => [
+            DataMapper::Query::Direction.new(QuerySpec::SailBoat.properties[:port], :asc)
           ])
           result[0].id.should == 3
 
-          result = SailBoat.all(:order => [
-            DataMapper::Query::Direction.new(SailBoat.properties[:name], :asc),
-            DataMapper::Query::Direction.new(SailBoat.properties[:port], :asc)
+          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 = SailBoat.all(:order => [
-            SailBoat.properties[:name],
-            DataMapper::Query::Direction.new(SailBoat.properties[:port], :asc)
+          result = QuerySpec::SailBoat.all(:order => [
+            QuerySpec::SailBoat.properties[:name],
+            DataMapper::Query::Direction.new(QuerySpec::SailBoat.properties[:port], :asc)
           ])
           result[0].id.should == 1
 
-          result = SailBoat.all(:order => [:name])
+          result = QuerySpec::SailBoat.all(:order => [ :name ])
           result[0].id.should == 1
 
-          result = SailBoat.all(:order => [:name.desc])
+          result = QuerySpec::SailBoat.all(:order => [ :name.desc ])
           result[0].id.should == 3
         end
       end
     end
 
     describe 'when sub-selecting' do
-      before :all do
-        class Permission
-          include DataMapper::Resource
-          property :id, Serial
-          property :user_id, Integer
-          property :resource_id, Integer
-          property :resource_type, String
-          property :token, String
-        end
-
-        class SailBoat
-          include DataMapper::Resource
-          property :id, Serial
-          property :name, String
-          property :port, String
-          property :captain, String
-        end
-      end
-
       before do
-        Permission.auto_migrate!(ADAPTER)
-        SailBoat.auto_migrate!(ADAPTER)
+        [ QuerySpec::SailBoat, QuerySpec::Permission ].each { |m| m.auto_migrate! }
 
-        repository(ADAPTER) do
-          SailBoat.create!(:id => 1, :name => "Fantasy I",      :port => "Cape Town", :captain => 'Joe')
-          SailBoat.create!(:id => 2, :name => "Royal Flush II", :port => "Cape Town", :captain => 'James')
-          SailBoat.create!(:id => 3, :name => "Infringer III",  :port => "Cape Town", :captain => 'Jason')
+        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
-          Permission.create!(:id => 1, :user_id => 1, :resource_id => 1, :resource_type => 'SailBoat', :token => 'READ')
-          Permission.create!(:id => 2, :user_id => 1, :resource_id => 2, :resource_type => 'SailBoat', :token => 'READ')
+        #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
-          Permission.create!(:id => 3, :user_id => 2, :resource_id => 2, :resource_type => 'SailBoat', :token => 'READ')
-          Permission.create!(:id => 4, :user_id => 2, :resource_id => 3, :resource_type => 'SailBoat', :token => 'READ')
-        end
+        #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), Permission, :user_id => 1, :resource_type => 'SailBoat', :token => 'READ', :fields => [ :resource_id ])
+        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) { SailBoat.all(query) }
+        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), Permission, :user_id => 2, :resource_type => 'SailBoat', :token => 'READ', :fields => [ :resource_id ])
+        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) { SailBoat.all(query) }
+        boats = repository(ADAPTER) { QuerySpec::SailBoat.all(query) }
 
         boats.should have(2).entries
         boats.entries[0].id.should == 2
@@ -154,130 +321,44 @@ if ADAPTER
 
       it 'when value is NOT IN another query' do
         # Boats that User 1 Cannot see
-        acl = DataMapper::Query.new(repository(ADAPTER), Permission, :user_id => 1, :resource_type => 'SailBoat', :token => 'READ', :fields => [:resource_id])
+        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) { SailBoat.all(query) }
+        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 :all do
-        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
-
-        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
-      end
-
       before do
-        Region.auto_migrate!
-        Factory.auto_migrate!
-        Vehicle.auto_migrate!
+        [ QuerySpec::Region, QuerySpec::Factory, QuerySpec::Vehicle ].each { |m| m.auto_migrate! }
 
-        Region.new(:id=>1, :name=>'North West').save
-        Factory.new(:id=>2000, :region_id=>1, :name=>'North West Plant').save
-        Vehicle.new(:id=>1, :factory_id=>2000, :name=>'10 ton delivery truck').save
+        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.new(:id=>1, :name=>'North West').save
-        Namespace::Factory.new(:id=>2000, :region_id=>1, :name=>'North West Plant').save
-        Namespace::Vehicle.new(:id=>1, :factory_id=>2000, :name=>'10 ton delivery truck').save
+        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 = Factory.properties(:mock)[:land]
+      #  land = QuerySpec::Factory.properties(:mock)[:land]
       #  fields = []
-      #  Vehicle.properties(ADAPTER).map do |property|
+      #  QuerySpec::Vehicle.properties(ADAPTER).map do |property|
       #    fields << property
       #  end
       #  fields << land
       #
       #  lambda{
       #    begin
-      #      results = repository(ADAPTER) { Vehicle.all(:links => [:factory], :fields => fields) }
+      #      results = repository(ADAPTER) { QuerySpec::Vehicle.all(:links => [ :factory ], :fields => fields) }
       #    rescue RuntimeError
-      #      $!.message.should == "Property Factory.land not available in repository #{ADAPTER}"
+      #      $!.message.should == "Property QuerySpec::Factory.land not available in repository #{ADAPTER}"
       #      raise $!
       #    end
       #  }.should raise_error(RuntimeError)
@@ -287,21 +368,21 @@ if ADAPTER
         factory = DataMapper::Associations::Relationship.new(
           :factory,
           ADAPTER,
-          'Vehicle',
-          'Factory',
+          'QuerySpec::Vehicle',
+          'QuerySpec::Factory',
           { :child_key => [ :factory_id ], :parent_key => [ :id ] }
         )
-        results = repository(ADAPTER) { Vehicle.all(:links => [factory]) }
+        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) { Vehicle.all(:links => [:factory]) }
+        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) { Vehicle.all(:links => ['factory']) }
+        results = repository(ADAPTER) { QuerySpec::Vehicle.all(:links => [ 'factory' ]) }
         results.should have(1).entries
       end
 
@@ -309,37 +390,37 @@ if ADAPTER
         region = DataMapper::Associations::Relationship.new(
           :region,
           ADAPTER,
-          'Factory',
-          'Region',
+          'QuerySpec::Factory',
+          'QuerySpec::Region',
           { :child_key => [ :region_id ], :parent_key => [ :id ] }
         )
-        results = repository(ADAPTER) { Vehicle.all(:links => ['factory',region]) }
+        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), Vehicle, :links => [1])
+          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), Vehicle, :links=>['Sailing'])
+          DataMapper::Query.new(repository(ADAPTER), QuerySpec::Vehicle, :links => [ 'Sailing' ])
         }.should raise_error(ArgumentError)
 
         lambda{
-          DataMapper::Query.new(repository(ADAPTER), Vehicle, :links=>[:sailing])
+          DataMapper::Query.new(repository(ADAPTER), QuerySpec::Vehicle, :links => [ :sailing ])
         }.should raise_error(ArgumentError)
       end
 
       it 'should create an n-level query path' do
-        Vehicle.factory.region.model.should == Region
-        Vehicle.factory.region.name.property.should == Region.properties(Region.repository.name)[:name]
+        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 = Vehicle.first(Vehicle.factory.region.name => 'North West')
+        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')
@@ -347,29 +428,30 @@ if ADAPTER
       end
 
       it "should accept a string representing a DM::QueryPath as they key to a condition" do
-        vehicle = Vehicle.first("factory.region.name" => 'North West')
+        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 = Vehicle.first(:includes => [Vehicle.factory])
+          vehicle = QuerySpec::Vehicle.first(:includes => [ QuerySpec::Vehicle.factory ])
         end
       end
 
       it "should behave when using mocks" do
-        class Group
-          include DataMapper::Resource
-          property :id, Serial
-          property :name, String
-        end
-
-        Group.should_receive(:all).with(:order => [:id.asc])
-        Group.all(:order => [:id.asc])
+        QuerySpec::Group.should_receive(:all).with(:order => [ :id.asc ])
+        QuerySpec::Group.all(:order => [ :id.asc ])
       end
     end   # describe links
   end # DM::Query