database_cleaner 0.8.0 → 0.9.1

data/examples/features/support/env.rb

@@ -5,7 +5,7 @@ require 'rubygems'
 require 'bundler'
 
 Bundler.setup
-require 'spec/expectations'
+require 'rspec/expectations'
 require 'ruby-debug'
 
 DB_DIR = "#{File.dirname(__FILE__)}/../../db"
@@ -42,9 +42,13 @@ if orm && strategy
     DatabaseCleaner.app_root = "#{File.dirname(__FILE__)}/../.."
     orm_sym = orm.gsub(/(.)([A-Z]+)/,'\1_\2').downcase.to_sym
 
-    if orm_sym == :mongo_mapper
+    case orm_sym
+    when :mongo_mapper
       DatabaseCleaner[ orm_sym, {:connection => 'database_cleaner_test_one'} ].strategy = strategy.to_sym
       DatabaseCleaner[ orm_sym, {:connection => 'database_cleaner_test_two'} ].strategy = strategy.to_sym
+    when :active_record
+      DatabaseCleaner[:active_record, {:model => ActiveRecordWidgetUsingDatabaseOne} ].strategy = strategy.to_sym
+      DatabaseCleaner[:active_record, {:model => ActiveRecordWidgetUsingDatabaseTwo} ].strategy = strategy.to_sym
     else
       DatabaseCleaner[ orm_sym, {:connection => :one} ].strategy = strategy.to_sym
       DatabaseCleaner[ orm_sym, {:connection => :two} ].strategy = strategy.to_sym

data/features/cleaning.feature

@@ -19,4 +19,4 @@ Feature: database cleaning
     | DataMapper   | truncation    |
     | MongoMapper  | truncation    |
     | Mongoid      | truncation    |
-    #    | CouchPotato  | truncation    |
+    | CouchPotato  | truncation    |

data/features/cleaning_default_strategy.feature

@@ -16,4 +16,4 @@ Feature: database cleaning
     | DataMapper   |
     | MongoMapper  |
     | Mongoid      |
-    #    | CouchPotato  |
+    | CouchPotato  |

data/features/cleaning_multiple_dbs.feature

@@ -17,5 +17,4 @@ Feature: multiple database cleaning
   | DataMapper   | truncation    |
   | MongoMapper  | truncation    |
   | DataMapper   | transaction   |
-# Not working...
-#| ActiveRecord | transaction   |
+  | ActiveRecord | transaction   |

data/features/cleaning_multiple_orms.feature

@@ -14,16 +14,16 @@ Feature: database cleaning using multiple ORMs
     | ActiveRecord | DataMapper   |
     | ActiveRecord | MongoMapper  |
     | ActiveRecord | Mongoid      |
-    #| ActiveRecord | CouchPotato  |
+    | ActiveRecord | CouchPotato  |
     | DataMapper   | ActiveRecord |
     | DataMapper   | MongoMapper  |
     | DataMapper   | Mongoid      |
-    #| DataMapper   | CouchPotato  |
+    | DataMapper   | CouchPotato  |
     | MongoMapper  | ActiveRecord |
     | MongoMapper  | DataMapper   |
     | MongoMapper  | Mongoid      |
-    #| MongoMapper  | CouchPotato  |
-    #    | CouchPotato  | ActiveRecord |
-    #| CouchPotato  | DataMapper   |
-    #| CouchPotato  | MongoMapper  |
-    #| CouchPotato  | Mongoid      |
+    | MongoMapper  | CouchPotato  |
+    | CouchPotato  | ActiveRecord |
+    | CouchPotato  | DataMapper   |
+    | CouchPotato  | MongoMapper  |
+    | CouchPotato  | Mongoid      |

data/features/support/env.rb

@@ -1,7 +1,7 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
 require 'database_cleaner'
 
-require 'spec/expectations'
+require 'rspec/expectations'
 
 require 'test/unit/assertions'
 

data/lib/database_cleaner/active_record/base.rb

@@ -38,16 +38,36 @@ module DatabaseCleaner
         end
       end
 
-      def create_connection_klass
+      def create_connection_class
         Class.new(::ActiveRecord::Base)
       end
 
-      def connection_klass
-        return ::ActiveRecord::Base unless connection_hash
-        klass = create_connection_klass
-        klass.send :establish_connection, connection_hash
-        klass
+      def connection_class
+        @connection_class ||= if @db == :default || (@db.nil? && connection_hash.nil?)
+                                ::ActiveRecord::Base
+                              elsif connection_hash
+                                lookup_from_connection_pool || establish_connection
+                              else
+                                @db # allows for an actual class to be passed in
+                              end
       end
+
+      private
+
+      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}
+        end
+      end
+
+      def establish_connection
+        strategy_class = create_connection_class
+        strategy_class.send :establish_connection, connection_hash
+        strategy_class
+      end
+    
     end
   end
 end

data/lib/database_cleaner/active_record/deletion.rb

@@ -27,7 +27,7 @@ module ActiveRecord
       end
     end
 
-    class PostgreSQLAdapter < AbstractAdapter
+    class PostgreSQLAdapter < POSTGRE_ADAPTER_PARENT
       def delete_table(table_name)
         execute("DELETE FROM #{quote_table_name(table_name)};")
       end
@@ -53,7 +53,7 @@ module DatabaseCleaner::ActiveRecord
   class Deletion < Truncation
 
     def clean
-      connection = connection_klass.connection
+      connection = connection_class.connection
       connection.disable_referential_integrity do
         tables_to_truncate(connection).each do |table_name|
           connection.delete_table table_name

data/lib/database_cleaner/active_record/transaction.rb

@@ -7,24 +7,24 @@ module DatabaseCleaner::ActiveRecord
     include ::DatabaseCleaner::Generic::Transaction
 
     def start
-      if connection_klass.connection.respond_to?(:increment_open_transactions)
-        connection_klass.connection.increment_open_transactions
+      if connection_class.connection.respond_to?(:increment_open_transactions)
+        connection_class.connection.increment_open_transactions
       else
-        connection_klass.__send__(:increment_open_transactions)
+        connection_class.__send__(:increment_open_transactions)
       end
-      connection_klass.connection.begin_db_transaction
+      connection_class.connection.begin_db_transaction
     end
 
 
     def clean
-      return unless connection_klass.connection.open_transactions > 0
+      return unless connection_class.connection.open_transactions > 0
 
-      connection_klass.connection.rollback_db_transaction
+      connection_class.connection.rollback_db_transaction
 
-      if connection_klass.connection.respond_to?(:decrement_open_transactions)
-        connection_klass.connection.decrement_open_transactions
+      if connection_class.connection.respond_to?(:decrement_open_transactions)
+        connection_class.connection.decrement_open_transactions
       else
-        connection_klass.__send__(:decrement_open_transactions)
+        connection_class.__send__(:decrement_open_transactions)
       end
     end
   end

data/lib/database_cleaner/active_record/truncation.rb

@@ -1,18 +1,30 @@
 require 'active_record/base'
+
 require 'active_record/connection_adapters/abstract_adapter'
+
+begin
+  require 'active_record/connection_adapters/abstract_mysql_adapter'
+rescue LoadError
+end
+
 require "database_cleaner/generic/truncation"
 require 'database_cleaner/active_record/base'
 
-module ActiveRecord
-  module ConnectionAdapters
-    # Activerecord-jdbc-adapter defines class dependencies a bit differently - if it is present, confirm to ArJdbc hierarchy to avoid 'superclass mismatch' errors.
-    USE_ARJDBC_WORKAROUND = defined?(ArJdbc)
+module DatabaseCleaner
+  module ActiveRecord
 
-    class AbstractAdapter
-      def views
+    module AbstractAdapter
+      # used to be called views but that can clash with gems like schema_plus
+      # this gem is not meant to be exposing such an extra interface any way
+      def database_cleaner_view_cache
         @views ||= select_values("select table_name from information_schema.views where table_schema = '#{current_database}'") rescue []
       end
 
+      def database_cleaner_table_cache
+        # the adapters don't do caching (#130) but we make the assumption that the list stays the same in tests
+        @database_cleaner_tables ||= tables
+      end
+
       def truncate_table(table_name)
         raise NotImplementedError
       end
@@ -24,42 +36,58 @@ module ActiveRecord
       end
     end
 
-    unless USE_ARJDBC_WORKAROUND
-      class SQLiteAdapter < AbstractAdapter
-      end
-    end
+    module MysqlAdapter
 
-    # ActiveRecord 3.1 support
-    if defined?(AbstractMysqlAdapter)
-      MYSQL_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractMysqlAdapter
-      MYSQL2_ADAPTER_PARENT = AbstractMysqlAdapter
-    else
-      MYSQL_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractAdapter
-      MYSQL2_ADAPTER_PARENT = AbstractAdapter
-    end
-    
-    SQLITE_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : SQLiteAdapter
-    POSTGRE_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractAdapter
-
-    class MysqlAdapter < MYSQL_ADAPTER_PARENT
       def truncate_table(table_name)
         execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
       end
-    end
 
-    class Mysql2Adapter < MYSQL2_ADAPTER_PARENT
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
+      def truncate_tables(tables)
+        tables.each { |t| truncate_table(t) }
+      end
+
+      def pre_count_truncate_tables(tables, options = {:reset_ids => true})
+        filter = options[:reset_ids] ? method(:has_been_used?) : method(:has_rows?)
+        truncate_tables(tables.select(&filter))
+      end
+
+      private
+
+
+      def row_count(table)
+        select_value("SELECT EXISTS (SELECT 1 FROM #{quote_table_name(table)} LIMIT 1)")
+      end
+
+      # Returns a boolean indicating if the given table has an auto-inc number higher than 0.
+      # Note, this is different than an empty table since an table may populated, the index increased,
+      # 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)
+        if row_count(table) > 0
+          true
+        else
+          select_value(<<-SQL) > 1 # returns nil if not present
+              SELECT Auto_increment
+              FROM information_schema.tables
+              WHERE table_name='#{table}';
+          SQL
+        end
+      end
+
+      def has_rows?(table)
+        row_count(table) > 0
       end
     end
 
-    class IBM_DBAdapter < AbstractAdapter
+
+    module IBM_DBAdapter
       def truncate_table(table_name)
         execute("TRUNCATE #{quote_table_name(table_name)} IMMEDIATE")
       end
     end
 
-    class SQLite3Adapter < SQLITE_ADAPTER_PARENT
+
+    module SQLiteAdapter
       def delete_table(table_name)
         execute("DELETE FROM #{quote_table_name(table_name)};")
         execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
@@ -67,7 +95,7 @@ module ActiveRecord
       alias truncate_table delete_table
     end
 
-    class JdbcAdapter < AbstractAdapter
+    module TruncateOrDelete
       def truncate_table(table_name)
         begin
           execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
@@ -77,8 +105,7 @@ module ActiveRecord
       end
     end
 
-    class PostgreSQLAdapter < POSTGRE_ADAPTER_PARENT
-
+    module PostgreSQLAdapter
       def db_version
         @db_version ||= postgresql_version
       end
@@ -94,25 +121,34 @@ module ActiveRecord
       def truncate_table(table_name)
         truncate_tables([table_name])
       end
-      
+
       def truncate_tables(table_names)
         return if table_names.nil? || table_names.empty?
         execute("TRUNCATE TABLE #{table_names.map{|name| quote_table_name(name)}.join(', ')} #{restart_identity} #{cascade};")
       end
 
-    end
+      def pre_count_truncate_tables(tables, options = {:reset_ids => true})
+        filter = options[:reset_ids] ? method(:has_been_used?) : method(:has_rows?)
+        truncate_tables(tables.select(&filter))
+      end
 
-    class SQLServerAdapter < AbstractAdapter
-      def truncate_table(table_name)
-        begin
-          execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
-        rescue ActiveRecord::StatementInvalid
-          execute("DELETE FROM #{quote_table_name(table_name)};")
-        end
+      private
+
+      # Returns a boolean indicating if the given table has an auto-inc number higher than 0.
+      # Note, this is different than an empty table since an table may populated, the index increased,
+      # 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
+      end
+
+      def has_rows?(table)
+        select_value("SELECT true FROM #{table} LIMIT 1;")
       end
     end
 
-    class OracleEnhancedAdapter < AbstractAdapter
+    module OracleEnhancedAdapter
       def truncate_table(table_name)
         execute("TRUNCATE TABLE #{quote_table_name(table_name)}")
       end
@@ -121,6 +157,69 @@ module ActiveRecord
   end
 end
 
+#TODO: Remove monkeypatching and decorate the connection instead!
+
+module ActiveRecord
+  module ConnectionAdapters
+    # Activerecord-jdbc-adapter defines class dependencies a bit differently - if it is present, confirm to ArJdbc hierarchy to avoid 'superclass mismatch' errors.
+    USE_ARJDBC_WORKAROUND = defined?(ArJdbc)
+
+    class AbstractAdapter
+      include ::DatabaseCleaner::ActiveRecord::AbstractAdapter
+    end
+
+    unless USE_ARJDBC_WORKAROUND
+      class SQLiteAdapter < AbstractAdapter
+      end
+    end
+
+    # ActiveRecord 3.1 support
+    if defined?(AbstractMysqlAdapter)
+      MYSQL_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractMysqlAdapter
+      MYSQL2_ADAPTER_PARENT = AbstractMysqlAdapter
+    else
+      MYSQL_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractAdapter
+      MYSQL2_ADAPTER_PARENT = AbstractAdapter
+    end
+
+    SQLITE_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : SQLiteAdapter
+    POSTGRE_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractAdapter
+
+    class MysqlAdapter < MYSQL_ADAPTER_PARENT
+      include ::DatabaseCleaner::ActiveRecord::MysqlAdapter
+    end
+
+    class Mysql2Adapter < MYSQL2_ADAPTER_PARENT
+      include ::DatabaseCleaner::ActiveRecord::MysqlAdapter
+    end
+
+    class IBM_DBAdapter < AbstractAdapter
+      include ::DatabaseCleaner::ActiveRecord::IBM_DBAdapter
+    end
+
+    class SQLite3Adapter < SQLITE_ADAPTER_PARENT
+      include ::DatabaseCleaner::ActiveRecord::SQLiteAdapter
+    end
+
+    class JdbcAdapter < AbstractAdapter
+      include ::DatabaseCleaner::ActiveRecord::TruncateOrDelete
+    end
+
+    class PostgreSQLAdapter < POSTGRE_ADAPTER_PARENT
+      include ::DatabaseCleaner::ActiveRecord::PostgreSQLAdapter
+    end
+
+    class SQLServerAdapter < AbstractAdapter
+      include ::DatabaseCleaner::ActiveRecord::TruncateOrDelete
+    end
+
+    class OracleEnhancedAdapter < AbstractAdapter
+      include ::DatabaseCleaner::ActiveRecord::OracleEnhancedAdapter
+    end
+
+  end
+end
+
 
 module DatabaseCleaner::ActiveRecord
   class Truncation
@@ -128,25 +227,33 @@ module DatabaseCleaner::ActiveRecord
     include ::DatabaseCleaner::Generic::Truncation
 
     def clean
-      connection = connection_klass.connection
+      connection = connection_class.connection
       connection.disable_referential_integrity do
-        connection.truncate_tables(tables_to_truncate(connection))
+        if pre_count? && connection.respond_to?(:pre_count_truncate_tables)
+          connection.pre_count_truncate_tables(tables_to_truncate(connection), {:reset_ids => reset_ids?})
+        else
+          connection.truncate_tables(tables_to_truncate(connection))
+        end
       end
     end
 
     private
 
     def tables_to_truncate(connection)
-       (@only || connection.tables) - @tables_to_exclude - connection.views
+      (@only || connection.database_cleaner_table_cache) - @tables_to_exclude - connection.database_cleaner_view_cache
     end
 
     # overwritten
-    def migration_storage_name
-      'schema_migrations'
+    def migration_storage_names
+      %w[schema_migrations]
+    end
+
+    def pre_count?
+      @pre_count == true
     end
 
+    def reset_ids?
+      @reset_ids != false
+    end
   end
 end
-
-
-