dm-core 0.9.2

data/spec/integration/property_spec.rb

@@ -0,0 +1,224 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+gem 'fastercsv', '>=1.2.3'
+require 'fastercsv'
+
+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 mutable 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_false
+
+          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_false
+          tim.notes = "Testing"
+          tim.dirty?.should be_true
+          tim.save
+        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
+    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

@@ -0,0 +1,376 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+if ADAPTER
+  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
+        end
+      end
+
+      before do
+        SailBoat.auto_migrate!(ADAPTER)
+
+        repository(ADAPTER) do
+          SailBoat.create!(:name => 'A', :port => 'C')
+          SailBoat.create!(:name => 'B', :port => 'B')
+          SailBoat.create!(:name => 'C', :port => 'A')
+        end
+      end
+
+      it "should find by conditions" do
+        lambda do
+          repository(ADAPTER) do
+            SailBoat.first(:conditions => ['name = ?', 'B'])
+          end
+        end.should_not raise_error
+
+        lambda do
+          repository(ADAPTER) do
+            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')
+
+          find = SailBoat.first(:name => 'couldbe@email.com')
+          find.name.should == 'couldbe@email.com'
+
+          find = 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 = SailBoat.all(:id => 0..2)
+          find.should_not be_nil
+          find.should have(2).entries
+
+          find = 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[0].id.should == 1
+
+          result = SailBoat.all(:order => [
+            DataMapper::Query::Direction.new(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[0].id.should == 1
+
+          result = SailBoat.all(:order => [
+            SailBoat.properties[:name],
+            DataMapper::Query::Direction.new(SailBoat.properties[:port], :asc)
+          ])
+          result[0].id.should == 1
+
+          result = SailBoat.all(:order => [:name])
+          result[0].id.should == 1
+
+          result = 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)
+
+        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')
+
+          #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 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
+      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 ])
+        query = { :port => 'Cape Town', :id => acl, :captain.like => 'J%', :order => [ :id ] }
+        boats = repository(ADAPTER) { 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 ])
+        query = { :port => 'Cape Town', :id => acl, :captain.like => 'J%', :order => [ :id ] }
+        boats = repository(ADAPTER) { 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), 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.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!
+
+        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
+
+        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
+      end
+
+      it 'should require that all properties in :fields and all :links come from the same repository' #do
+      #  land = Factory.properties(:mock)[:land]
+      #  fields = []
+      #  Vehicle.properties(ADAPTER).map do |property|
+      #    fields << property
+      #  end
+      #  fields << land
+      #
+      #  lambda{
+      #    begin
+      #      results = repository(ADAPTER) { Vehicle.all(:links => [:factory], :fields => fields) }
+      #    rescue RuntimeError
+      #      $!.message.should == "Property 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,
+          'Vehicle',
+          'Factory',
+          { :child_key => [ :factory_id ], :parent_key => [ :id ] }
+        )
+        results = repository(ADAPTER) { 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.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.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,
+          'Factory',
+          'Region',
+          { :child_key => [ :region_id ], :parent_key => [ :id ] }
+        )
+        results = repository(ADAPTER) { 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])
+        }.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'])
+        }.should raise_error(ArgumentError)
+
+        lambda{
+          DataMapper::Query.new(repository(ADAPTER), 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]
+      end
+
+      it 'should accept a DM::QueryPath as the key to a condition' do
+        vehicle = Vehicle.first(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 = Vehicle.first("factory.region.name" => 'North West')
+        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])
+        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])
+      end
+    end   # describe links
+  end # DM::Query
+end