datamapper-dm-core 0.9.11 → 0.10.0

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

data/spec/integration/repository_spec.rb

@@ -1,61 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-if ADAPTER
-  describe DataMapper::Repository, "with #{ADAPTER}" do
-    before :all do
-      class ::SerialFinderSpec
-        include DataMapper::Resource
-
-        property :id, Serial
-        property :sample, String
-
-        auto_migrate!(ADAPTER)
-      end
-
-      repository(ADAPTER).create((0...100).map { SerialFinderSpec.new(:sample => rand.to_s) })
-    end
-
-    before do
-      @repository = repository(ADAPTER)
-      @model      = SerialFinderSpec
-      @query      = DataMapper::Query.new(@repository, @model)
-    end
-
-    it 'should be serializable with Marshal' do
-      Marshal.load(Marshal.dump(@repository)).should == @repository
-    end
-
-    it "should throw an exception if the named repository is unknown" do
-      r = DataMapper::Repository.new(:completely_bogus)
-      lambda { r.adapter }.should raise_error(ArgumentError)
-    end
-
-    it "should return all available rows" do
-      @repository.read_many(@query).should have(100).entries
-    end
-
-    it "should allow limit and offset" do
-      @repository.read_many(@query.merge(:limit => 50)).should have(50).entries
-
-      collection = @repository.read_many(@query.merge(:limit => 20, :offset => 40))
-      collection.should have(20).entries
-      collection.map { |entry| entry.id }.should == @repository.read_many(@query)[40...60].map { |entry| entry.id }
-    end
-
-    it "should lazy-load missing attributes" do
-      sfs = @repository.read_one(@query.merge(:fields => [ :id ], :limit => 1))
-      sfs.should be_a_kind_of(@model)
-      sfs.should_not be_a_new_record
-
-      sfs.attribute_loaded?(:sample).should be_false
-      sfs.sample.should_not be_nil
-    end
-
-    it "should translate an Array to an IN clause" do
-      ids = @repository.read_many(@query.merge(:fields => [ :id ], :limit => 10)).map { |entry| entry.id }
-      results = @repository.read_many(@query.merge(:id => ids))
-
-      results.map { |entry| entry.id }.should == ids
-    end
-  end
-end