database_cleaner 0.9.1 → 1.0.0.RC1

data/lib/database_cleaner/active_record/base.rb

@@ -32,9 +32,9 @@ module DatabaseCleaner
       end
 
       def load_config
-        if self.db != :default && File.file?(ActiveRecord.config_file_location)
-          connection_details   = YAML::load(ERB.new(IO.read(ActiveRecord.config_file_location)).result)
-          @connection_hash = connection_details[self.db.to_s]
+        if self.db != :default && self.db.is_a?(Symbol) && File.file?(ActiveRecord.config_file_location)
+          connection_details = YAML::load(ERB.new(IO.read(ActiveRecord.config_file_location)).result)
+          @connection_hash   = connection_details[self.db.to_s]
         end
       end
 
@@ -43,12 +43,12 @@ module DatabaseCleaner
       end
 
       def connection_class
-        @connection_class ||= if @db == :default || (@db.nil? && connection_hash.nil?)
-                                ::ActiveRecord::Base
+        @connection_class ||= if @db && !@db.is_a?(Symbol)
+                                @db
                               elsif connection_hash
                                 lookup_from_connection_pool || establish_connection
                               else
-                                @db # allows for an actual class to be passed in
+                                ::ActiveRecord::Base
                               end
       end
 
@@ -57,8 +57,8 @@ module DatabaseCleaner
       def lookup_from_connection_pool
         if ::ActiveRecord::Base.respond_to?(:descendants)
           database_name = connection_hash["database"] || connection_hash[:database]
-          models = ::ActiveRecord::Base.descendants
-          models.detect {|m| m.connection_pool.spec.config[:database] == database_name}
+          models        = ::ActiveRecord::Base.descendants
+          models.detect { |m| m.connection_pool.spec.config[:database] == database_name }
         end
       end
 
@@ -67,7 +67,7 @@ module DatabaseCleaner
         strategy_class.send :establish_connection, connection_hash
         strategy_class
       end
-    
+
     end
   end
 end

data/lib/database_cleaner/active_record/deletion.rb

@@ -3,51 +3,6 @@ require 'active_record/connection_adapters/abstract_adapter'
 require "database_cleaner/generic/truncation"
 require 'database_cleaner/active_record/base'
 require 'database_cleaner/active_record/truncation'
-# This file may seem to have duplication with that of truncation, but by keeping them separate
-# we avoiding loading this code when it is not being used (which is the common case).
-
-module ActiveRecord
-  module ConnectionAdapters
-
-    class MysqlAdapter < MYSQL_ADAPTER_PARENT
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    class Mysql2Adapter < MYSQL2_ADAPTER_PARENT
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    class JdbcAdapter < AbstractAdapter
-      def delete_table(table_name)
-          execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    class PostgreSQLAdapter < POSTGRE_ADAPTER_PARENT
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    class SQLServerAdapter < AbstractAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    class OracleEnhancedAdapter < AbstractAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)}")
-      end
-    end
-
-  end
-end
-
 
 module DatabaseCleaner::ActiveRecord
   class Deletion < Truncation
@@ -55,9 +10,11 @@ module DatabaseCleaner::ActiveRecord
     def clean
       connection = connection_class.connection
       connection.disable_referential_integrity do
-        tables_to_truncate(connection).each do |table_name|
-          connection.delete_table table_name
-        end
+        sql = tables_to_truncate(connection).map do |table_name|
+          "DELETE FROM #{connection.quote_table_name(table_name)}"
+        end.join(";")
+
+        connection.execute sql
       end
     end
 

data/lib/database_cleaner/active_record/transaction.rb

@@ -7,25 +7,47 @@ module DatabaseCleaner::ActiveRecord
     include ::DatabaseCleaner::Generic::Transaction
 
     def start
-      if connection_class.connection.respond_to?(:increment_open_transactions)
-        connection_class.connection.increment_open_transactions
+      if connection_maintains_transaction_count?
+        if connection_class.connection.respond_to?(:increment_open_transactions)
+          connection_class.connection.increment_open_transactions
+        else
+          connection_class.__send__(:increment_open_transactions)
+        end
+      end
+      if connection_class.connection.respond_to?(:begin_transaction)
+        connection_class.connection.begin_transaction
       else
-        connection_class.__send__(:increment_open_transactions)
+        connection_class.connection.begin_db_transaction
       end
-      connection_class.connection.begin_db_transaction
     end
 
 
     def clean
       return unless connection_class.connection.open_transactions > 0
 
-      connection_class.connection.rollback_db_transaction
-
-      if connection_class.connection.respond_to?(:decrement_open_transactions)
-        connection_class.connection.decrement_open_transactions
+      if connection_class.connection.respond_to?(:rollback_transaction)
+        connection_class.connection.rollback_transaction
       else
-        connection_class.__send__(:decrement_open_transactions)
+        connection_class.connection.rollback_db_transaction
       end
+
+      # The below is for handling after_commit hooks.. see https://github.com/bmabey/database_cleaner/issues/99
+      if connection_class.connection.respond_to?(:rollback_transaction_records)
+        connection_class.connection.send(:rollback_transaction_records, true)
+      end
+
+      if connection_maintains_transaction_count?
+        if connection_class.connection.respond_to?(:decrement_open_transactions)
+          connection_class.connection.decrement_open_transactions
+        else
+          connection_class.__send__(:decrement_open_transactions)
+        end
+      end
+    end
+
+    def connection_maintains_transaction_count?
+      ActiveRecord::VERSION::MAJOR < 4
     end
+
   end
 end

data/lib/database_cleaner/active_record/truncation.rb

@@ -55,7 +55,9 @@ module DatabaseCleaner
 
 
       def row_count(table)
-        select_value("SELECT EXISTS (SELECT 1 FROM #{quote_table_name(table)} LIMIT 1)")
+        # Patch for MysqlAdapter with ActiveRecord 3.2.7 later
+        # select_value("SELECT 1") #=> "1"
+        select_value("SELECT EXISTS (SELECT 1 FROM #{quote_table_name(table)} LIMIT 1)").to_i
       end
 
       # Returns a boolean indicating if the given table has an auto-inc number higher than 0.
@@ -66,7 +68,9 @@ module DatabaseCleaner
         if row_count(table) > 0
           true
         else
-          select_value(<<-SQL) > 1 # returns nil if not present
+          # Patch for MysqlAdapter with ActiveRecord 3.2.7 later
+          # select_value("SELECT 1") #=> "1"
+          select_value(<<-SQL).to_i > 1 # returns nil if not present
               SELECT Auto_increment
               FROM information_schema.tables
               WHERE table_name='#{table}';
@@ -90,9 +94,18 @@ module DatabaseCleaner
     module SQLiteAdapter
       def delete_table(table_name)
         execute("DELETE FROM #{quote_table_name(table_name)};")
-        execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
+        if uses_sequence
+          execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
+        end
       end
       alias truncate_table delete_table
+
+      private
+
+      # Returns a boolean indicating if the SQLite database is using the sqlite_sequence table.
+      def uses_sequence
+        select_value("SELECT name FROM sqlite_master WHERE type='table' AND name='sqlite_sequence';")
+      end
     end
 
     module TruncateOrDelete
@@ -139,8 +152,8 @@ module DatabaseCleaner
       # but then the table is cleaned.  In other words, this function tells us if the given table
       # was ever inserted into.
       def has_been_used?(table)
-        cur_val = select_value("SELECT currval('#{table}_id_seq');").to_i rescue ActiveRecord::StatementInvalid
-        cur_val && cur_val > 0
+        cur_val = select_value("SELECT currval('#{table}_id_seq');").to_i rescue 0
+        cur_val > 0
       end
 
       def has_rows?(table)
@@ -182,7 +195,11 @@ module ActiveRecord
       MYSQL2_ADAPTER_PARENT = AbstractAdapter
     end
 
-    SQLITE_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : SQLiteAdapter
+    if defined?(SQLite3Adapter) && SQLite3Adapter.superclass == ActiveRecord::ConnectionAdapters::AbstractAdapter
+      SQLITE_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractAdapter
+    else
+      SQLITE_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : SQLiteAdapter
+    end
     POSTGRE_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractAdapter
 
     class MysqlAdapter < MYSQL_ADAPTER_PARENT

data/lib/database_cleaner/data_mapper/truncation.rb

@@ -53,7 +53,9 @@ module DataMapper
 
       def truncate_table(table_name)
         execute("DELETE FROM #{quote_name(table_name)};")
-        execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
+        if uses_sequence
+          execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
+        end
       end
 
       # this is a no-op copied from activerecord
@@ -80,7 +82,9 @@ module DataMapper
 
       def truncate_table(table_name)
         execute("DELETE FROM #{quote_name(table_name)};")
-        execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
+        if uses_sequence
+          execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
+        end
       end
 
       # this is a no-op copied from activerecord

data/lib/database_cleaner/sequel/truncation.rb

@@ -35,7 +35,7 @@ module DatabaseCleaner
       private
 
       def tables_to_truncate(db)
-        (@only || db.tables) - @tables_to_exclude
+        (@only || db.tables.map(&:to_s)) - @tables_to_exclude
       end
 
       # overwritten

data/spec/database_cleaner/active_record/base_spec.rb

@@ -62,7 +62,7 @@ module DatabaseCleaner
 
         before do
           subject.db = :my_db
-          yaml = <<-Y
+          yaml       = <<-Y
 my_db:
   database: <%= "ONE".downcase %>
           Y
@@ -71,7 +71,7 @@ my_db:
         end
 
         it "should parse the config" do
-          YAML.should_receive(:load).and_return( {:nil => nil} )
+          YAML.should_receive(:load).and_return({ :nil => nil })
           subject.load_config
         end
 
@@ -80,19 +80,26 @@ my_db:
 my_db:
   database: one
           Y
-          YAML.should_receive(:load).with(transformed).and_return({ "my_db" => {"database" => "one"} })
+          YAML.should_receive(:load).with(transformed).and_return({ "my_db" => { "database" => "one" } })
           subject.load_config
         end
 
         it "should store the relevant config in connection_hash" do
           subject.load_config
-          subject.connection_hash.should == {"database" => "one"}
+          subject.connection_hash.should == { "database" => "one" }
         end
 
         it "should skip config if config file is not available" do
           File.should_receive(:file?).with(config_location).and_return(false)
           subject.load_config
-          subject.connection_hash.should be_blank
+          subject.connection_hash.should_not be
+        end
+
+        it "skips the file when the model is set" do
+          subject.db = FakeModel
+          YAML.should_not_receive(:load)
+          subject.load_config
+          subject.connection_hash.should_not be
         end
 
         it "skips the file when the db is set to :default" do
@@ -100,6 +107,7 @@ my_db:
           subject.db = :default
           YAML.should_not_receive(:load)
           subject.load_config
+          subject.connection_hash.should_not be
         end
 
       end
@@ -122,19 +130,32 @@ my_db:
       end
 
       describe "connection_class" do
-        it { expect{ subject.connection_class }.to_not raise_error }
+        it { expect { subject.connection_class }.to_not raise_error }
         it "should default to ActiveRecord::Base" do
           subject.connection_class.should == ::ActiveRecord::Base
         end
 
-        it "allows for database models to be passed in" do
-          subject.db = FakeModel
-          subject.connection_class.should == FakeModel
+        context "with database models" do
+          context "connection_hash is set" do
+            it "allows for database models to be passed in" do
+              subject.db = FakeModel
+              subject.connection_hash = { }
+              subject.load_config
+              subject.connection_class.should == FakeModel
+            end
+          end
+
+          context "connection_hash is not set" do
+            it "allows for database models to be passed in" do
+              subject.db = FakeModel
+              subject.connection_class.should == FakeModel
+            end
+          end
         end
 
         context "when connection_hash is set" do
           let(:hash) { mock("hash") }
-          before { ::ActiveRecord::Base.stub!(:respond_to?).and_return(false)}
+          before { ::ActiveRecord::Base.stub!(:respond_to?).and_return(false) }
           before { subject.stub(:connection_hash).and_return(hash) }
 
           it "should create connection_class if it doesnt exist if connection_hash is set" do
@@ -142,7 +163,7 @@ my_db:
             subject.connection_class
           end
 
-          it  "should configure the class from create_connection_class if connection_hash is set" do
+          it "should configure the class from create_connection_class if connection_hash is set" do
             strategy_class = mock('strategy_class')
             strategy_class.should_receive(:establish_connection).with(hash)
 

data/spec/database_cleaner/active_record/transaction_spec.rb

@@ -8,70 +8,129 @@ module DatabaseCleaner
     describe Transaction do
       let (:connection) { mock("connection") }
       before(:each) do
-        ::ActiveRecord::Base.stub!(:connection).and_return(connection)
+        ::ActiveRecord::Base.stub(:connection).and_return(connection)
       end
 
       describe "#start" do
-        it "should increment open transactions if possible" do
-          connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(true)
-          connection.stub!(:begin_db_transaction)
-
-          connection.should_receive(:increment_open_transactions)
-          Transaction.new.start
-        end
-
-        it "should tell ActiveRecord to increment connection if its not possible to increment current connection" do
-          connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(false)
-          connection.stub!(:begin_db_transaction)
-
-          ::ActiveRecord::Base.should_receive(:increment_open_transactions)
-          Transaction.new.start
-        end
-
-        it "should start a transaction" do
-            connection.stub!(:increment_open_transactions)
-
-            connection.should_receive(:begin_db_transaction)
-            Transaction.new.start
+        [:begin_transaction, :begin_db_transaction].each do |begin_transaction_method|
+          context "using #{begin_transaction_method}" do
+            before do
+              connection.stub(begin_transaction_method)
+              connection.stub(:respond_to?).with(:begin_transaction).and_return(:begin_transaction == begin_transaction_method)
+            end
+
+            it "should increment open transactions if possible" do
+              connection.stub(:respond_to?).with(:increment_open_transactions).and_return(true)
+              connection.should_receive(:increment_open_transactions)
+              Transaction.new.start
+            end
+
+            it "should tell ActiveRecord to increment connection if its not possible to increment current connection" do
+              connection.stub(:respond_to?).with(:increment_open_transactions).and_return(false)
+              ::ActiveRecord::Base.should_receive(:increment_open_transactions)
+              Transaction.new.start
+            end
+
+            it "should start a transaction" do
+              connection.stub(:respond_to?).with(:increment_open_transactions).and_return(true)
+              connection.stub(:increment_open_transactions)
+              connection.should_receive(begin_transaction_method)
+              Transaction.new.start
+            end
+          end
         end
       end
 
       describe "#clean" do
-        it "should start a transaction" do
+        context "manual accounting of transaction count" do
+          it "should start a transaction" do
             connection.should_receive(:open_transactions).and_return(1)
 
-            connection.stub!(:decrement_open_transactions)
+            connection.stub(:decrement_open_transactions)
 
             connection.should_receive(:rollback_db_transaction)
             Transaction.new.clean
-        end
+          end
+
+          it "should decrement open transactions if possible" do
+            connection.should_receive(:open_transactions).and_return(1)
 
-        it "should decrement open transactions if possible" do
-          connection.should_receive(:open_transactions).and_return(1)
+            connection.stub(:respond_to?).with(:decrement_open_transactions).and_return(true)
+            connection.stub(:respond_to?).with(:rollback_transaction_records).and_return(false)
+            connection.stub(:respond_to?).with(:rollback_transaction).and_return(false)
+            connection.stub(:rollback_db_transaction)
 
-          connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(true)
-          connection.stub!(:rollback_db_transaction)
+            connection.should_receive(:decrement_open_transactions)
+            Transaction.new.clean
+          end
 
-          connection.should_receive(:decrement_open_transactions)
-          Transaction.new.clean
-        end
+          it "should not try to decrement or rollback if open_transactions is 0 for whatever reason" do
+            connection.should_receive(:open_transactions).and_return(0)
 
-        it "should not try to decrement or rollback if open_transactions is 0 for whatever reason" do
-          connection.should_receive(:open_transactions).and_return(0)
+            Transaction.new.clean
+          end
 
-          Transaction.new.clean
+          it "should decrement connection via ActiveRecord::Base if connection won't" do
+            connection.should_receive(:open_transactions).and_return(1)
+            connection.stub(:respond_to?).with(:decrement_open_transactions).and_return(false)
+            connection.stub(:respond_to?).with(:rollback_transaction_records).and_return(false)
+            connection.stub(:respond_to?).with(:rollback_transaction).and_return(false)
+            connection.stub(:rollback_db_transaction)
+
+            ::ActiveRecord::Base.should_receive(:decrement_open_transactions)
+            Transaction.new.clean
+          end
         end
 
-        it "should decrement connection via ActiveRecord::Base if connection won't" do
-          connection.should_receive(:open_transactions).and_return(1)
-          connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(false)
-          connection.stub!(:rollback_db_transaction)
+        context "automatic accounting of transaction count (AR 4)" do
+          before {stub_const("ActiveRecord::VERSION::MAJOR", 4) }
+
+          it "should start a transaction" do
+            connection.stub(:rollback_db_transaction)
+            connection.should_receive(:open_transactions).and_return(1)
+
+            connection.should_not_receive(:decrement_open_transactions)
+            connection.should_receive(:rollback_transaction)
+            Transaction.new.clean
+          end
+
+          it "should decrement open transactions if possible" do
+            connection.stub(:rollback_transaction)
+            connection.should_receive(:open_transactions).and_return(1)
+
+            connection.should_not_receive(:decrement_open_transactions)
+            Transaction.new.clean
+          end
+
+          it "should not try to decrement or rollback if open_transactions is 0 for whatever reason" do
+            connection.should_receive(:open_transactions).and_return(0)
+
+            Transaction.new.clean
+          end
+
+          it "should decrement connection via ActiveRecord::Base if connection won't" do
+            connection.should_receive(:open_transactions).and_return(1)
+            connection.stub(:respond_to?).with(:rollback_transaction_records).and_return(false)
+            connection.stub(:respond_to?).with(:rollback_transaction).and_return(true)
+            connection.stub(:rollback_transaction)
 
-          ::ActiveRecord::Base.should_receive(:decrement_open_transactions)
-          Transaction.new.clean
+            ::ActiveRecord::Base.should_not_receive(:decrement_open_transactions)
+            Transaction.new.clean
+          end
         end
       end
-    end
 
+      describe "#connection_maintains_transaction_count?" do
+        it "should return true if the major active record version is < 4" do
+          stub_const("ActiveRecord::VERSION::MAJOR", 3)
+          Transaction.new.connection_maintains_transaction_count?.should be_true
+        end
+        it "should return false if the major active record version is > 3" do
+          stub_const("ActiveRecord::VERSION::MAJOR", 4)
+          Transaction.new.connection_maintains_transaction_count?.should be_false
+        end
+      end
+
+    end
   end
 end