dm-core 0.9.11 → 0.10.0

data/spec/public/shared/sel_shared_spec.rb

@@ -0,0 +1,112 @@
+share_examples_for 'A Collection supporting Strategic Eager Loading' do
+  describe 'using SEL when looping within a loop' do
+    before :all do
+      @many_to_many = @articles.kind_of?(DataMapper::Associations::ManyToMany::Collection)
+    end
+
+    before :all do
+      attributes = {}
+
+      unless @many_to_many
+        attributes[:author] = @author
+      end
+
+      @revision = @article.revisions.create(attributes.merge(:title => 'Revision'))
+
+      @new_article  = @article_model.create(attributes.merge(:title => 'Sample Article'))
+      @new_revision = @new_article.revisions.create(attributes.merge(:title => 'New Revision'))
+    end
+
+    before :all do
+      @original_adapter = @adapter
+
+      @adapter.meta_class.class_eval do
+        def eql?(other)
+          super || self == other
+        end
+      end
+
+      @adapter = DataMapper::Repository.adapters[@adapter.name] = CounterAdapter.new(@adapter)
+      @repository.instance_variable_set(:@adapter, @adapter)
+    end
+
+    before :all do
+      @results = []
+
+      @articles.each do |article|
+        article.revisions.each do |revision|
+          @results << [ article, revision ]
+        end
+      end
+    end
+
+    after :all do
+      @adapter = @original_adapter
+    end
+
+    it "should only execute the Adapter#read #{loaded ? 'once' : 'twice'}" do
+      @adapter.counts[:read].should == (loaded ? 1 : 2)
+    end
+
+    it 'should return the expected results' do
+      # if the collection is already loaded, then when it iterates it will
+      # not know about the newly added articles and their revisions
+      if loaded
+        @results.should == [ [ @article, @revision ] ]
+      else
+        pending_if 'TODO: make m:m not kick when delegating to the relationship', @many_to_many do
+          @results.should == [ [ @article, @revision ], [ @new_article, @new_revision ] ]
+        end
+      end
+    end
+  end
+end
+
+share_examples_for 'A Resource supporting Strategic Eager Loading' do
+  describe 'using SEL when inside a Collection' do
+    before :all do
+      @referrer = @user_model.create(:name => 'Referrer', :comment => @comment)
+
+      @user.update(:referrer => @referrer)
+
+      @new_user = @user_model.create(:name => 'Another User', :referrer => @referrer, :comment => @comment)
+    end
+
+    before :all do
+      @original_adapter = @adapter
+
+      @adapter.meta_class.class_eval do
+        def eql?(other)
+          super || other == self
+        end
+      end
+
+      @adapter = DataMapper::Repository.adapters[@adapter.name] = CounterAdapter.new(@adapter)
+      @repository.instance_variable_set(:@adapter, @adapter)
+    end
+
+    before :all do
+      @results = []
+
+      @user_model.all.each do |user|
+        @results << [ user, user.referrer ]
+      end
+
+      # some storage engines return the data in a different order
+      @results.sort!
+    end
+
+    after :all do
+      @adapter = @original_adapter
+    end
+
+    it 'should only execute the Adapter#read twice' do
+      @adapter.counts[:read].should == 2
+    end
+
+    it 'should return the expected results' do
+      # results are ordered alphabetically by the User name
+      @results.should == [ [ @new_user, @referrer ], [ @referrer, nil ], [ @user, @referrer ] ]
+    end
+  end
+end

data/spec/public/transaction_spec.rb

@@ -0,0 +1,129 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe DataMapper::Resource, 'Transactions' do
+  before :all do
+    module ::Blog
+      class User
+        include DataMapper::Resource
+
+        property :name,        String, :key => true
+        property :age,         Integer
+        property :summary,     Text
+        property :description, Text
+        property :admin,       Boolean, :accessor => :private
+
+        belongs_to :referrer, self, :nullable => true
+        has n, :comments
+
+        # FIXME: figure out a different approach than stubbing things out
+        def comment=(*)
+          # do nothing with comment
+        end
+      end
+
+      class Author < User; end
+
+      class Comment
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :body, Text
+
+        belongs_to :user
+      end
+
+      class Article
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :body, Text
+
+        has n, :paragraphs
+      end
+
+      class Paragraph
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :text, String
+
+        belongs_to :article
+      end
+    end
+
+    @user_model      = Blog::User
+    @author_model    = Blog::Author
+    @comment_model   = Blog::Comment
+    @article_model   = Blog::Article
+    @paragraph_model = Blog::Paragraph
+  end
+
+  supported_by :postgres, :mysql, :sqlite3, :oracle do
+    before :all do
+      user = @user_model.create(:name => 'dbussink', :age => 25, :description => 'Test')
+
+      @user = @user_model.get(*user.key)
+    end
+
+    before do
+      # --- Temporary private api use to get around rspec limitations ---
+      @repository.scope do |repository|
+        transaction = DataMapper::Transaction.new(repository)
+        transaction.begin
+        repository.adapter.push_transaction(transaction)
+      end
+    end
+
+    after do
+      while @repository.adapter.current_transaction
+        @repository.adapter.pop_transaction.rollback
+      end
+    end
+
+    it_should_behave_like 'A public Resource'
+    it_should_behave_like 'A Resource supporting Strategic Eager Loading'
+  end
+
+  supported_by :postgres, :mysql, :sqlite3, :oracle do
+    describe '#transaction' do
+      before do
+        @user_model.all.destroy!
+      end
+
+      it 'should have access to resources presisted before the transaction' do
+        @user_model.create(:name => 'carllerche')
+        @user_model.transaction do
+          @user_model.first.name.should == 'carllerche'
+        end
+      end
+
+      it 'should have access to resources persisted in the transaction' do
+        @user_model.transaction do
+          @user_model.create(:name => 'carllerche')
+          @user_model.first.name.should == 'carllerche'
+        end
+      end
+
+      it 'should not mark saved resources as new records' do
+        @user_model.transaction do
+          @user_model.create(:name => 'carllerche').should_not be_new
+        end
+      end
+
+      it 'should rollback when an error is thrown in a transaction' do
+        @user_model.all.should have(0).entries
+        lambda {
+          @user_model.transaction do
+            @user_model.create(:name => 'carllerche')
+            raise 'I love coffee'
+          end
+        }.should raise_error('I love coffee')
+        @user_model.all.should have(0).entries
+      end
+
+      it 'should return the last statement in the transaction block' do
+        @user_model.transaction { 1 }.should == 1
+      end
+    end
+  end
+end

data/spec/public/types/discriminator_spec.rb

@@ -0,0 +1,130 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe DataMapper::Types::Discriminator do
+  before :all do
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+
+        property :id,    Serial
+        property :title, String, :nullable => false
+        property :type,  Discriminator
+      end
+
+      class Announcement < Article; end
+      class Release < Announcement; end
+    end
+
+    @article_model      = Blog::Article
+    @announcement_model = Blog::Announcement
+    @release_model      = Blog::Release
+  end
+
+  it 'should typecast to a Model' do
+    @article_model.properties[:type].typecast('Blog::Release').should equal(@release_model)
+  end
+
+  describe 'Model#new' do
+    describe 'when provided a String discriminator in the attributes' do
+      before :all do
+        @resource = @article_model.new(:type => 'Blog::Release')
+      end
+
+      it 'should return a Resource' do
+        @resource.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be an descendant instance' do
+        @resource.should be_instance_of(Blog::Release)
+      end
+    end
+
+    describe 'when provided a Class discriminator in the attributes' do
+      before :all do
+        @resource = @article_model.new(:type => Blog::Release)
+      end
+
+      it 'should return a Resource' do
+        @resource.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be an descendant instance' do
+        @resource.should be_instance_of(Blog::Release)
+      end
+    end
+
+    describe 'when not provided a discriminator in the attributes' do
+      before :all do
+        @resource = @article_model.new
+      end
+
+      it 'should return a Resource' do
+        @resource.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be a base model instance' do
+        @resource.should be_instance_of(@article_model)
+      end
+    end
+  end
+
+  describe 'Model#descendants' do
+    it 'should set the descendants for the grandparent model' do
+      @article_model.descendants.to_a.should == [ @article_model, @announcement_model, @release_model ]
+    end
+
+    it 'should set the descendants for the parent model' do
+      @announcement_model.descendants.to_a.should == [ @announcement_model, @release_model ]
+    end
+
+    it 'should set the descendants for the child model' do
+      @release_model.descendants.to_a.should == [ @release_model ]
+    end
+  end
+
+  describe 'Model#default_scope' do
+    it 'should set the default scope for the grandparent model' do
+      @article_model.default_scope[:type].should equal(@article_model.descendants)
+    end
+
+    it 'should set the default scope for the parent model' do
+      @announcement_model.default_scope[:type].should equal(@announcement_model.descendants)
+    end
+
+    it 'should set the default scope for the child model' do
+      @release_model.default_scope[:type].should equal(@release_model.descendants)
+    end
+  end
+
+  supported_by :all do
+    before :all do
+      @skip = defined?(DataMapper::Adapters::YamlAdapter) && @adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+    end
+
+    before do
+      pending if @skip
+    end
+
+    before :all do
+      rescue_if 'TODO: fix YAML serialization/deserialization', @skip do
+        @announcement = @announcement_model.create(:title => 'Announcement')
+      end
+    end
+
+    it 'should persist the type' do
+      @announcement.model.get(*@announcement.key).type.should equal(@announcement_model)
+    end
+
+    it 'should be retrieved as an instance of the correct class' do
+      @announcement.model.get(*@announcement.key).should be_instance_of(@announcement_model)
+    end
+
+    it 'should include descendants in finders' do
+      @article_model.first.should eql(@announcement)
+    end
+
+    it 'should not include ancestors' do
+      @release_model.first.should be_nil
+    end
+  end
+end

data/spec/semipublic/adapters/abstract_adapter_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe 'AbstractAdapter' do
+  before :all do
+    @adapter = DataMapper::Adapters::AbstractAdapter.new(:abstract, :foo => 'bar')
+    @adapter_class = @adapter.class
+    @scheme        = Extlib::Inflection.underscore(Extlib::Inflection.demodulize(@adapter_class).chomp('Adapter'))
+    @adapter_name  = "test_#{@scheme}".to_sym
+  end
+
+  describe 'initialization' do
+
+    describe 'name' do
+      it 'should have a name' do
+        @adapter.name.should == :abstract
+      end
+    end
+
+    it 'should set options' do
+      @adapter.options.should == {:foo => 'bar'}
+    end
+
+    it 'should set naming conventions' do
+      @adapter.resource_naming_convention.should == DataMapper::NamingConventions::Resource::UnderscoredAndPluralized
+      @adapter.field_naming_convention.should    == DataMapper::NamingConventions::Field::Underscored
+    end
+
+  end
+
+end

data/spec/semipublic/adapters/in_memory_adapter_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require DataMapper.root / 'lib' / 'dm-core' / 'spec' / 'adapter_shared_spec'
+
+describe 'Adapter' do
+  supported_by :in_memory do
+    describe DataMapper::Adapters::InMemoryAdapter do
+
+      it_should_behave_like 'An Adapter'
+
+    end
+  end
+end

data/spec/semipublic/adapters/mysql_adapter_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+dir = DataMapper.root / 'lib' / 'dm-core' / 'spec'
+
+require dir / 'adapter_shared_spec'
+require dir / 'data_objects_adapter_shared_spec'
+
+describe 'Adapter' do
+  supported_by :mysql do
+    describe DataMapper::Adapters::MysqlAdapter do
+
+      it_should_behave_like 'An Adapter'
+      it_should_behave_like 'A DataObjects Adapter'
+
+    end
+  end
+end

data/spec/semipublic/adapters/oracle_adapter_spec.rb

@@ -0,0 +1,194 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+dir = DataMapper.root / 'lib' / 'dm-core' / 'spec'
+
+require dir / 'adapter_shared_spec'
+require dir / 'data_objects_adapter_shared_spec'
+
+module SQLLogHelper
+  class SQLLogger
+    attr_accessor :buffer
+    def initialize
+      @buffer = ""
+    end
+
+    def level; 0; end
+
+    def debug(string)
+      @buffer << string << "\n"
+      # puts "#{string.gsub(/\n/m,"<br/>\n")}<br/>"
+    end
+  end
+
+  def start_sql_log!
+    return if @sql_log_on
+    @sql_log_on = true
+    @old_logger = DataObjects::Oracle.logger
+    DataObjects::Oracle.logger = SQLLogger.new
+  end
+
+  def stop_sql_log!
+    return unless @sql_log_on
+    @sql_log_on = nil
+    DataObjects::Oracle.logger = @old_logger
+  end
+
+  def clear_sql_log!
+    return unless @sql_log_on
+    DataObjects::Oracle.logger.buffer = ""
+  end
+
+  def sql_log_buffer
+    DataObjects::Oracle.logger.buffer
+  end
+end
+
+describe 'Adapter' do
+  supported_by :oracle do
+    describe DataMapper::Adapters::OracleAdapter do
+
+      it_should_behave_like 'An Adapter'
+      it_should_behave_like 'A DataObjects Adapter'
+
+      describe "sequences" do
+        include SQLLogHelper
+
+        before(:all) do
+          @auto_migrate_with = DataMapper::Adapters::OracleAdapter.auto_migrate_with
+          DataMapper::Adapters::OracleAdapter.auto_migrate_with :drop_and_create
+          start_sql_log!
+        end
+
+        after(:all) do
+          stop_sql_log!
+          DataMapper::Adapters::OracleAdapter.auto_migrate_with @auto_migrate_with
+        end
+
+        describe "create default sequence and trigger" do
+          before(:all) do
+            class ::Employee
+              include DataMapper::Resource
+              property :employee_id,  Serial
+            end
+            Employee.auto_migrate!
+          end
+
+          after(:all) do
+            Employee.auto_migrate_down!
+          end
+
+          it "should not have sequence name in options" do
+            Employee.properties[:employee_id].options[:sequence].should be_nil
+          end
+
+          it "should create default sequence" do
+            sql_log_buffer.should =~ /CREATE SEQUENCE "EMPLOYEES_SEQ"/
+          end
+
+          it "should create trigger" do
+            sql_log_buffer.should =~ /CREATE OR REPLACE TRIGGER "EMPLOYEES_PKT"/
+          end
+
+        end
+
+        describe "create custom sequence" do
+
+          before(:all) do
+            class ::Employee
+              include DataMapper::Resource
+              property :employee_id,  Serial, :sequence => "emp_seq"
+            end
+            Employee.auto_migrate!
+          end
+
+          after(:all) do
+            Employee.auto_migrate_down!
+          end
+
+          it "should have custom sequence name" do
+            Employee.properties[:employee_id].options[:sequence].should == "emp_seq"
+          end
+
+          it "should create custom sequence" do
+            sql_log_buffer.should =~ /CREATE SEQUENCE "EMP_SEQ"/
+          end
+
+          it "should not create trigger" do
+            sql_log_buffer.should_not =~ /TRIGGER/
+          end
+
+        end
+
+        describe "create custom sequence in non-default repository" do
+
+          before(:all) do
+            stop_sql_log!
+            DataMapper.setup :oracle, DataMapper::Repository.adapters[:default].options
+            start_sql_log!
+            class ::Employee
+              include DataMapper::Resource
+              property :id,  Serial
+              repository(:oracle) do
+                property :id,  Serial, :field => "employee_id", :sequence => "emp_seq"
+              end
+            end
+            repository(:oracle) do
+              Employee.auto_migrate!
+            end
+          end
+
+          after(:all) do
+            repository(:oracle) do
+              Employee.auto_migrate_down!
+            end
+          end
+
+          it "should have custom sequence name" do
+            Employee.properties(:oracle)[:id].options[:sequence].should == "emp_seq"
+          end
+
+          it "should create custom sequence" do
+            sql_log_buffer.should =~ /CREATE SEQUENCE "EMP_SEQ"/
+          end
+
+          it "should not create trigger" do
+            sql_log_buffer.should_not =~ /TRIGGER/
+          end
+
+        end
+
+        describe "prefetch key value from custom sequence" do
+
+          before(:all) do
+            class ::Employee
+              include DataMapper::Resource
+              property :employee_id,  Serial, :sequence => "emp_seq"
+              property :first_name,   String
+            end
+            Employee.auto_migrate!
+          end
+
+          after(:all) do
+            Employee.auto_migrate_down!
+          end
+
+          it "should prefetch sequence value when inserting new record" do
+            e = Employee.create
+            e.employee_id.should == 1
+            e = Employee.create(:first_name => "Raimonds")
+            e.employee_id.should == 2
+          end
+
+          it "should insert explicitly specified primary key value" do
+            e = Employee.create(:employee_id => 100,:first_name => "Raimonds")
+            e.employee_id.should == 100
+          end
+
+        end
+
+
+      end
+
+    end
+  end
+end