dm-core 0.9.11 → 0.10.0

data/spec/integration/strategic_eager_loading_spec.rb

@@ -1,156 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe "Strategic Eager Loading" do
-  include LoggingHelper
-
-  before :all do
-    class ::Zoo
-      include DataMapper::Resource
-      def self.default_repository_name; ADAPTER end
-
-      property :id, Serial
-      property :name, String
-
-      has n, :exhibits
-    end
-
-    class ::Exhibit
-      include DataMapper::Resource
-      def self.default_repository_name; ADAPTER end
-
-      property :id, Serial
-      property :name, String
-      property :zoo_id, Integer
-
-      belongs_to :zoo
-      has n, :animals
-    end
-
-    class ::Animal
-      include DataMapper::Resource
-      def self.default_repository_name; ADAPTER end
-
-      property :id, Serial
-      property :name, String
-      property :exhibit_id, Integer
-
-      belongs_to :exhibit
-    end
-
-    [Zoo, Exhibit, Animal].each { |k| k.auto_migrate!(ADAPTER) }
-
-    repository(ADAPTER) do
-      Zoo.create(:name => "Dallas Zoo")
-      Exhibit.create(:name => "Primates", :zoo_id => 1)
-      Animal.create(:name => "Chimpanzee", :exhibit_id => 1)
-      Animal.create(:name => "Orangutan", :exhibit_id => 1)
-
-      Zoo.create(:name => "San Diego")
-      Exhibit.create(:name => "Aviary", :zoo_id => 2)
-      Exhibit.create(:name => "Insectorium", :zoo_id => 2)
-      Exhibit.create(:name => "Bears", :zoo_id => 2)
-      Animal.create(:name => "Bald Eagle", :exhibit_id => 2)
-      Animal.create(:name => "Parakeet", :exhibit_id => 2)
-      Animal.create(:name => "Roach", :exhibit_id => 3)
-      Animal.create(:name => "Brown Bear", :exhibit_id => 4)
-    end
-  end
-
-  it "should eager load children" do
-    zoo_ids     = Zoo.all.map { |z| z.key }
-    exhibit_ids = Exhibit.all.map { |e| e.key }
-
-    repository(ADAPTER) do
-      zoos = Zoo.all.entries # load all zoos
-      dallas = zoos.find { |z| z.name == 'Dallas Zoo' }
-
-      logger do |log|
-        dallas.exhibits.entries # load all exhibits for zoos in identity_map
-        dallas.exhibits.size.should == 1
-
-        log.readlines.size.should == 1
-
-        repository.identity_map(Zoo).keys.sort.should == zoo_ids
-        repository.identity_map(Exhibit).keys.sort.should == exhibit_ids
-      end
-
-      logger do |log|
-        zoos.each { |zoo| zoo.exhibits.entries } # issues no queries
-        log.readlines.should be_empty
-      end
-
-      dallas.exhibits << Exhibit.new(:name => "Reptiles")
-      dallas.exhibits.size.should == 2
-      dallas.save
-    end
-    repository(ADAPTER) do
-      Zoo.first.exhibits.size.should == 2
-    end
-  end
-
-  it "should not eager load children when a query is provided" do
-    repository(ADAPTER) do
-      dallas = Zoo.all.entries.find { |z| z.name == 'Dallas Zoo' }
-      exhibits = dallas.exhibits.entries # load all exhibits
-
-      reptiles, primates = nil, nil
-
-      logger do |log|
-        reptiles = dallas.exhibits(:name => 'Reptiles')
-        reptiles.size.should == 1
-
-        log.readlines.size.should == 1
-      end
-
-      logger do |log|
-        primates = dallas.exhibits(:name => 'Primates')
-        primates.size.should == 1
-        primates.should_not == reptiles
-
-        log.readlines.size.should == 1
-      end
-    end
-  end
-
-  it "should eager load parents" do
-    animal_ids  = Animal.all.map { |a| a.key }
-    exhibit_ids = Exhibit.all.map { |e| e.key }.sort
-    exhibit_ids.pop # remove Reptile exhibit, which has no Animals
-
-    repository(ADAPTER) do
-      animals = Animal.all.entries
-      bear = animals.find { |a| a.name == 'Brown Bear' }
-
-      logger do |log|
-        bear.exhibit
-
-        repository.identity_map(Animal).keys.sort.should == animal_ids
-        repository.identity_map(Exhibit).keys.sort.should == exhibit_ids
-
-        log.readlines.size.should == 1
-      end
-    end
-  end
-
-  it "should not eager load parents when parent is in IM" do
-    repository(ADAPTER) do
-      animal = Animal.first
-      exhibit = Exhibit.get(1) # load exhibit into IM
-
-      logger do |log|
-        animal.exhibit # load exhibit from IM
-        log.readlines.should be_empty
-      end
-
-      repository.identity_map(Exhibit).keys.should == [exhibit.key]
-    end
-  end
-
-  it "should return a Collection when no children" do
-    Zoo.create(:name => 'Portland')
-
-    Zoo.all.each do |zoo|
-      zoo.exhibits.should be_kind_of(DataMapper::Collection)
-    end
-  end
-end

data/spec/integration/transaction_spec.rb

@@ -1,75 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-# transaction capable adapters
-ADAPTERS = []
-ADAPTERS << :postgres if HAS_POSTGRES
-ADAPTERS << :mysql    if HAS_MYSQL
-ADAPTERS << :sqlite3  if HAS_SQLITE3
-
-if ADAPTERS.any?
-  class Sputnik
-    include DataMapper::Resource
-
-    property :id, Serial
-    property :name, DM::Text
-  end
-
-  describe DataMapper::Transaction do
-    before :all do
-      @repositories = []
-
-      ADAPTERS.each do |name|
-        @repositories << repository(name)
-      end
-    end
-
-    before :each do
-      ADAPTERS.each do |name|
-        Sputnik.auto_migrate!(name)
-      end
-    end
-
-    it "should commit changes to all involved adapters on a two phase commit" do
-      DataMapper::Transaction.new(*@repositories) do
-        ADAPTERS.each do |name|
-          repository(name) { Sputnik.create(:name => 'hepp') }
-        end
-      end
-
-      ADAPTERS.each do |name|
-        repository(name) { Sputnik.all.size.should == 1 }
-      end
-    end
-
-    it "should not commit any changes if the block raises an exception" do
-      lambda do
-        DataMapper::Transaction.new(*@repositories) do
-          ADAPTERS.each do |name|
-            repository(name) { Sputnik.create(:name => 'hepp') }
-          end
-          raise "plur"
-        end
-      end.should raise_error(Exception, /plur/)
-
-      ADAPTERS.each do |name|
-        repository(name) { Sputnik.all.size.should == 0 }
-      end
-    end
-
-    it "should not commit any changes if any of the adapters doesnt prepare properly" do
-      lambda do
-        DataMapper::Transaction.new(*@repositories) do |transaction|
-          ADAPTERS.each do |name|
-            repository(name) { Sputnik.create(:name => 'hepp') }
-          end
-
-          transaction.primitive_for(@repositories.last.adapter).should_receive(:prepare).and_throw(Exception.new("I am the famous test exception"))
-        end
-      end.should raise_error(Exception, /I am the famous test exception/)
-
-      ADAPTERS.each do |name|
-        repository(name) { Sputnik.all.size.should == 0 }
-      end
-    end
-  end
-end

data/spec/integration/type_spec.rb

@@ -1,275 +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
-
-if ADAPTER
-  module ::TypeTests
-    class Impostor < DataMapper::Type
-      primitive String
-    end
-
-    class Coconut
-      include DataMapper::Resource
-
-      storage_names[ADAPTER] = 'coconuts'
-
-      def self.default_repository_name
-        ADAPTER
-      end
-
-      property :id, Serial
-      property :faked, Impostor
-      property :active, Boolean
-      property :note, Text
-    end
-  end
-
-  class ::Lemon
-    include DataMapper::Resource
-
-    def self.default_repository_name
-      ADAPTER
-    end
-
-    property :id, Serial
-    property :color, String
-    property :deleted_at, DataMapper::Types::ParanoidDateTime
-  end
-
-  class ::Lime
-    include DataMapper::Resource
-
-    def self.default_repository_name
-      ADAPTER
-    end
-
-    property :id, Serial
-    property :color, String
-    property :deleted_at, DataMapper::Types::ParanoidBoolean
-  end
-
-  describe DataMapper::Type, "with #{ADAPTER}" do
-    before do
-      TypeTests::Coconut.auto_migrate!(ADAPTER)
-
-      @document = <<-EOS.margin
-        NAME, RATING, CONVENIENCE
-        Freebird's, 3, 3
-        Whataburger, 1, 5
-        Jimmy John's, 3, 4
-        Mignon, 5, 2
-        Fuzi Yao's, 5, 1
-        Blue Goose, 5, 1
-      EOS
-
-      @stuff = YAML::dump({ 'Happy Cow!' => true, 'Sad Cow!' => false })
-
-      @active = true
-      @note = "This is a note on our ol' guy bob"
-    end
-
-    it "should instantiate an object with custom types" do
-      coconut = TypeTests::Coconut.new(:faked => 'bob', :active => @active, :note => @note)
-      coconut.faked.should == 'bob'
-      coconut.active.should be_a_kind_of(TrueClass)
-      coconut.note.should be_a_kind_of(String)
-    end
-
-    it "should CRUD an object with custom types" do
-      repository(ADAPTER) do
-        coconut = TypeTests::Coconut.new(:faked => 'bob', :active => @active, :note => @note)
-        coconut.save.should be_true
-        coconut.id.should_not be_nil
-
-        fred = TypeTests::Coconut.get!(coconut.id)
-        fred.faked.should == 'bob'
-        fred.active.should be_a_kind_of(TrueClass)
-        fred.note.should be_a_kind_of(String)
-
-        note = "Seems like bob is just mockin' around"
-        fred.note = note
-
-        fred.save.should be_true
-
-        active = false
-        fred.active = active
-
-        fred.save.should be_true
-
-        # Can't call coconut.reload since coconut.collection isn't setup.
-        mac = TypeTests::Coconut.get!(fred.id)
-        mac.active.should == active
-        mac.note.should == note
-      end
-    end
-
-    it "should respect paranoia with a datetime" do
-      Lemon.auto_migrate!(ADAPTER)
-
-      lemon = nil
-
-      repository(ADAPTER) do |repository|
-        lemon = Lemon.new
-        lemon.color = 'green'
-
-        lemon.save
-        lemon.destroy
-
-        lemon.deleted_at.should be_kind_of(DateTime)
-      end
-
-      repository(ADAPTER) do |repository|
-        Lemon.all.should be_empty
-        Lemon.get(lemon.id).should be_nil
-      end
-    end
-
-    it "should provide access to paranoid items with DateTime" do
-      Lemon.auto_migrate!(ADAPTER)
-
-      lemon = nil
-
-      repository(ADAPTER) do |repository|
-        %w(red green yellow blue).each do |color|
-          Lemon.create(:color => color)
-        end
-
-        Lemon.all.size.should == 4
-        Lemon.first.destroy
-        Lemon.all.size.should == 3
-        Lemon.with_deleted{Lemon.all.size.should == 1}
-      end
-    end
-
-    it "should set paranoid datetime to a date time" do
-      tmp = (DateTime.now - 0.5)
-      dt = DateTime.now
-      DateTime.stub!(:now).and_return(tmp)
-
-      repository(ADAPTER) do |repository|
-        lemon = Lemon.new
-        lemon.color = 'green'
-        lemon.save
-        lemon.destroy
-        lemon.deleted_at.should == tmp
-      end
-    end
-
-    it "should respect paranoia with a boolean" do
-      Lime.auto_migrate!(ADAPTER)
-
-      lime = nil
-
-      repository(ADAPTER) do |repository|
-        lime = Lime.new
-        lime.color = 'green'
-
-        lime.save
-        lime.destroy
-
-        lime.deleted_at.should be_kind_of(TrueClass)
-      end
-
-      repository(ADAPTER) do |repository|
-        Lime.all.should be_empty
-        Lime.get(lime.id).should be_nil
-      end
-    end
-
-    it "should provide access to paranoid items with Boolean" do
-      Lime.auto_migrate!(ADAPTER)
-
-      lemon = nil
-
-      repository(ADAPTER) do |repository|
-        %w(red green yellow blue).each do |color|
-          Lime.create(:color => color)
-        end
-
-        Lime.all.size.should == 4
-        Lime.first.destroy
-        Lime.all.size.should == 3
-        Lime.with_deleted{Lime.all.size.should == 1}
-      end
-    end
-
-    describe "paranoid types across repositories" do
-      before(:all) do
-        DataMapper::Repository.adapters[:alternate_paranoid] = repository(ADAPTER).adapter.dup
-
-        Object.send(:remove_const, :Orange) if defined?(Orange)
-        class ::Orange
-          include DataMapper::Resource
-
-          def self.default_repository_name
-            ADAPTER
-          end
-
-          property :id, Serial
-          property :color, String
-
-          repository(:alternate_paranoid) do
-            property :deleted,    DataMapper::Types::ParanoidBoolean
-            property :deleted_at, DataMapper::Types::ParanoidDateTime
-          end
-        end
-
-        repository(:alternate_paranoid){Orange.auto_migrate!}
-      end
-
-      before(:each) do
-        %w(red orange blue green).each{|color| o = Orange.create(:color => color)}
-      end
-
-      after(:each) do
-        Orange.repository.adapter.execute("DELETE FROM oranges")
-      end
-
-      it "should setup the correct objects for the spec" do
-        repository(:alternate_paranoid){Orange.all.should have(4).items}
-      end
-
-      it "should allow access the the default repository" do
-        Orange.all.should have(4).items
-      end
-
-      it "should mark the objects as deleted in the alternate_paranoid repository" do
-        repository(:alternate_paranoid) do
-          Orange.first.destroy
-          Orange.all.should have(3).items
-          Orange.find_by_sql("SELECT * FROM oranges").should have(4).items
-        end
-      end
-
-      it "should mark the objects as deleted in the alternate_paranoid repository but ignore it in the #{ADAPTER} repository" do
-        repository(:alternate_paranoid) do
-          Orange.first.destroy
-        end
-        Orange.all.should have(4).items
-      end
-
-      it "should raise an error when trying to destroy from a repository that is not paranoid" do
-        lambda do
-          Orange.first.destroy
-        end.should raise_error(ArgumentError)
-      end
-
-      it "should set all paranoid attributes on delete" do
-        repository(:alternate_paranoid) do
-          orange = Orange.first
-          orange.deleted.should be_false
-          orange.deleted_at.should be_nil
-          orange.destroy
-
-          orange.deleted.should be_true
-          orange.deleted_at.should be_a_kind_of(DateTime)
-        end
-      end
-    end
-  end
-end