database_cleaner 1.8.2 → 2.0.0.beta

data/TODO

@@ -1,3 +0,0 @@
-Could be more Datamapper
-MongoMapper multiple db support
-CouchDB multiple db support

data/adapters/database_cleaner-active_record/lib/database_cleaner-active_record.rb

@@ -1 +0,0 @@
-require "database_cleaner/active_record"

data/adapters/database_cleaner-active_record/lib/database_cleaner/active_record.rb

@@ -1,6 +0,0 @@
-require 'database_cleaner/active_record/version'
-require 'database_cleaner'
-require 'database_cleaner/active_record/deletion'
-require 'database_cleaner/active_record/transaction'
-require 'database_cleaner/active_record/truncation'
-

data/adapters/database_cleaner-active_record/lib/database_cleaner/active_record/base.rb

@@ -1,101 +0,0 @@
-require 'active_record'
-require 'database_cleaner/generic/base'
-require 'erb'
-require 'yaml'
-
-module DatabaseCleaner
-  module ActiveRecord
-    def self.available_strategies
-      %w[truncation transaction deletion]
-    end
-
-    def self.default_strategy
-      :transaction
-    end
-
-    def self.config_file_location=(path)
-      @config_file_location = path
-    end
-
-    def self.config_file_location
-      @config_file_location ||= begin
-        # Has DC.app_root been set? Check in this intrusive way to avoid triggering deprecation warnings if it hasn't.
-        app_root = DatabaseCleaner.send(:configuration).instance_variable_get(:@app_root)
-        root = app_root || Dir.pwd
-        "#{root}/config/database.yml"
-      end
-    end
-
-    module Base
-      include ::DatabaseCleaner::Generic::Base
-
-      attr_accessor :connection_hash
-
-      def db=(desired_db)
-        @db = desired_db
-        load_config
-      end
-
-      def db
-        @db ||= super
-      end
-
-      def load_config
-        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   = valid_config(connection_details)[self.db.to_s]
-        end
-      end
-
-      def valid_config(connection_file)
-        if !::ActiveRecord::Base.configurations.nil? && !::ActiveRecord::Base.configurations.empty?
-          if connection_file != ::ActiveRecord::Base.configurations
-            return ::ActiveRecord::Base.configurations
-          end
-        end
-        connection_file
-      end
-
-      def connection_class
-        @connection_class ||= if db && !db.is_a?(Symbol)
-                                db
-                              elsif connection_hash
-                                lookup_from_connection_pool || establish_connection
-                              else
-                                ::ActiveRecord::Base
-                              end
-      end
-
-      def self.migration_table_name
-        if ::ActiveRecord::VERSION::MAJOR < 5
-          ::ActiveRecord::Migrator.schema_migrations_table_name
-        else
-          ::ActiveRecord::SchemaMigration.table_name
-        end
-      end
-
-      def self.exclusion_condition(column_name)
-        result = " #{column_name} <> '#{::DatabaseCleaner::ActiveRecord::Base.migration_table_name}' "
-        if ::ActiveRecord::VERSION::MAJOR >= 5
-          result += " AND #{column_name} <> '#{::ActiveRecord::Base.internal_metadata_table_name}' "
-        end
-        result
-      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.select(&:connection_pool).detect { |m| m.connection_pool.spec.config[:database] == database_name }
-        end
-      end
-
-      def establish_connection
-        ::ActiveRecord::Base.establish_connection(connection_hash)
-        ::ActiveRecord::Base
-      end
-    end
-  end
-end

data/adapters/database_cleaner-active_record/lib/database_cleaner/active_record/deletion.rb

@@ -1,108 +0,0 @@
-require 'active_record'
-require 'active_record/connection_adapters/abstract_adapter'
-require "database_cleaner/generic/truncation"
-require 'database_cleaner/active_record/truncation'
-
-module DatabaseCleaner
-  module ConnectionAdapters
-    module AbstractDeleteAdapter
-      def delete_table(table_name)
-        raise NotImplementedError
-      end
-    end
-
-    module GenericDeleteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    module OracleDeleteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)}")
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    AbstractAdapter.class_eval { include DatabaseCleaner::ConnectionAdapters::AbstractDeleteAdapter }
-
-    JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(JdbcAdapter)
-    AbstractMysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(AbstractMysqlAdapter)
-    Mysql2Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(Mysql2Adapter)
-    SQLiteAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLiteAdapter)
-    SQLite3Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLite3Adapter)
-    PostgreSQLAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(PostgreSQLAdapter)
-    IBM_DBAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(IBM_DBAdapter)
-    SQLServerAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLServerAdapter)
-    OracleEnhancedAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleDeleteAdapter } if defined?(OracleEnhancedAdapter)
-  end
-end
-
-module DatabaseCleaner::ActiveRecord
-  module SelectiveTruncation
-    def tables_to_truncate(connection)
-      if information_schema_exists?(connection)
-        (@only || tables_with_new_rows(connection)) - @tables_to_exclude
-      else
-        super
-      end
-    end
-
-    def tables_with_new_rows(connection)
-      stats = table_stats_query(connection)
-      if stats != ''
-        connection.select_values(stats)
-      else
-        []
-      end
-    end
-
-    def table_stats_query(connection)
-      @table_stats_query ||= build_table_stats_query(connection)
-    ensure
-      @table_stats_query = nil unless @cache_tables
-    end
-
-    def build_table_stats_query(connection)
-      tables = connection.select_values(<<-SQL)
-        SELECT table_name
-        FROM information_schema.tables
-        WHERE table_schema = database()
-        AND #{::DatabaseCleaner::ActiveRecord::Base.exclusion_condition('table_name')};
-      SQL
-      queries = tables.map do |table|
-        "(SELECT #{connection.quote(table)} FROM #{connection.quote_table_name(table)} LIMIT 1)"
-      end
-      queries.join(' UNION ALL ')
-    end
-
-    def information_schema_exists? connection
-      return false unless connection.is_a? ActiveRecord::ConnectionAdapters::Mysql2Adapter
-      @information_schema_exists ||=
-        begin
-          connection.execute("SELECT 1 FROM information_schema.tables")
-          true
-        rescue
-          false
-        end
-    end
-  end
-
-  class Deletion < Truncation
-    if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
-      include SelectiveTruncation
-    end
-
-    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
-      end
-    end
-  end
-end

data/adapters/database_cleaner-active_record/lib/database_cleaner/active_record/transaction.rb

@@ -1,59 +0,0 @@
-require 'database_cleaner/active_record/base'
-require 'database_cleaner/generic/transaction'
-
-module DatabaseCleaner::ActiveRecord
-  class Transaction
-    include ::DatabaseCleaner::ActiveRecord::Base
-    include ::DatabaseCleaner::Generic::Transaction
-
-    def start
-      # Hack to make sure that the connection is properly setup for
-      # the clean code.
-      connection_class.connection.transaction{ }
-
-      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 :joinable => false
-      else
-        connection_class.connection.begin_db_transaction
-      end
-    end
-
-
-    def clean
-      connection_class.connection_pool.connections.each do |connection|
-        next unless connection.open_transactions > 0
-
-        if connection.respond_to?(:rollback_transaction)
-          connection.rollback_transaction
-        else
-          connection.rollback_db_transaction
-        end
-
-        # The below is for handling after_commit hooks.. see https://github.com/bmabey/database_cleaner/issues/99
-        if connection.respond_to?(:rollback_transaction_records, true)
-          connection.send(:rollback_transaction_records, true)
-        end
-
-        if connection_maintains_transaction_count?
-          if connection.respond_to?(:decrement_open_transactions)
-            connection.decrement_open_transactions
-          else
-            connection_class.__send__(:decrement_open_transactions)
-          end
-        end
-      end
-    end
-
-    def connection_maintains_transaction_count?
-      ActiveRecord::VERSION::MAJOR < 4
-    end
-
-  end
-end

data/adapters/database_cleaner-active_record/lib/database_cleaner/active_record/truncation.rb

@@ -1,280 +0,0 @@
-require 'active_record/base'
-require 'database_cleaner/active_record/base'
-require 'active_record/connection_adapters/abstract_adapter'
-
-#Load available connection adapters
-%w(
-  abstract_mysql_adapter postgresql_adapter sqlite3_adapter mysql_adapter mysql2_adapter oracle_enhanced_adapter
-).each do |known_adapter|
-  begin
-    require "active_record/connection_adapters/#{known_adapter}"
-  rescue LoadError
-  end
-end
-
-require "database_cleaner/generic/truncation"
-require 'database_cleaner/active_record/base'
-
-module DatabaseCleaner
-  module ConnectionAdapters
-
-    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 ||= database_tables
-      end
-
-      def database_tables
-        ::ActiveRecord::VERSION::MAJOR >= 5 ? data_sources : tables
-      end
-
-      def truncate_table(table_name)
-        raise NotImplementedError
-      end
-
-      def truncate_tables(tables)
-        tables.each do |table_name|
-          self.truncate_table(table_name)
-        end
-      end
-    end
-
-    module AbstractMysqlAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
-      end
-
-      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)
-        # 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
-
-      def auto_increment_value(table)
-        select_value(<<-SQL).to_i
-          SELECT auto_increment
-          FROM information_schema.tables
-          WHERE table_name = '#{table}'
-          AND table_schema = database()
-        SQL
-      end
-
-      # This method tells us if the given table has been inserted into since its
-      # last truncation. Note that the table might have been populated, which
-      # increased the auto-increment counter, but then cleaned again such that
-      # it appears empty now.
-      def has_been_used?(table)
-        has_rows?(table) || auto_increment_value(table) > 1
-      end
-
-      def has_rows?(table)
-        row_count(table) > 0
-      end
-    end
-
-    module IBM_DBAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE #{quote_table_name(table_name)} IMMEDIATE")
-      end
-    end
-
-    module SQLiteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-        if uses_sequence
-          execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
-        end
-      end
-      alias truncate_table delete_table
-
-      def truncate_tables(tables)
-        tables.each { |t| truncate_table(t) }
-      end
-
-      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
-      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
-      end
-    end
-
-    module OracleAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)}")
-      end
-    end
-
-    module PostgreSQLAdapter
-      def db_version
-        @db_version ||= postgresql_version
-      end
-
-      def cascade
-        @cascade ||= db_version >=  80200 ? 'CASCADE' : ''
-      end
-
-      def restart_identity
-        @restart_identity ||= db_version >=  80400 ? 'RESTART IDENTITY' : ''
-      end
-
-      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
-
-      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
-
-      def database_cleaner_table_cache
-        # AR returns a list of tables without schema but then returns a
-        # migrations table with the schema. There are other problems, too,
-        # with using the base list. If a table exists in multiple schemas
-        # within the search path, truncation without the schema name could
-        # result in confusing, if not unexpected results.
-        @database_cleaner_tables ||= tables_with_schema
-      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)
-        return has_rows?(table) unless has_sequence?(table)
-
-        cur_val = select_value("SELECT currval('#{table}_id_seq');").to_i rescue 0
-        cur_val > 0
-      end
-
-      def has_sequence?(table)
-        select_value("SELECT true FROM pg_class WHERE relname = '#{table}_id_seq';")
-      end
-
-      def has_rows?(table)
-        select_value("SELECT true FROM #{table} LIMIT 1;")
-      end
-
-      def tables_with_schema
-        rows = select_rows <<-_SQL
-          SELECT schemaname || '.' || tablename
-          FROM pg_tables
-          WHERE
-            tablename !~ '_prt_' AND
-            #{::DatabaseCleaner::ActiveRecord::Base.exclusion_condition('tablename')} AND
-            schemaname = ANY (current_schemas(false))
-        _SQL
-        rows.collect { |result| result.first }
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    #Apply adapter decoraters where applicable (adapter should be loaded)
-    AbstractAdapter.class_eval { include DatabaseCleaner::ConnectionAdapters::AbstractAdapter }
-
-    if defined?(JdbcAdapter)
-      if defined?(OracleJdbcConnection)
-        JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleAdapter }
-      else
-        JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::TruncateOrDelete }
-      end
-    end
-    AbstractMysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(AbstractMysqlAdapter)
-    Mysql2Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(Mysql2Adapter)
-    MysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(MysqlAdapter)
-    SQLiteAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::SQLiteAdapter } if defined?(SQLiteAdapter)
-    SQLite3Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::SQLiteAdapter } if defined?(SQLite3Adapter)
-    PostgreSQLAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::PostgreSQLAdapter } if defined?(PostgreSQLAdapter)
-    IBM_DBAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::IBM_DBAdapter } if defined?(IBM_DBAdapter)
-    SQLServerAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::TruncateOrDelete } if defined?(SQLServerAdapter)
-    OracleEnhancedAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleAdapter } if defined?(OracleEnhancedAdapter)
-  end
-end
-
-module DatabaseCleaner::ActiveRecord
-  class Truncation
-    include ::DatabaseCleaner::ActiveRecord::Base
-    include ::DatabaseCleaner::Generic::Truncation
-
-    def clean
-      connection = connection_class.connection
-      connection.disable_referential_integrity do
-        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)
-      tables_in_db = cache_tables? ? connection.database_cleaner_table_cache : connection.database_tables
-      to_reject = (@tables_to_exclude + connection.database_cleaner_view_cache)
-      (@only || tables_in_db).reject do |table|
-        if ( m = table.match(/([^.]+)$/) )
-          to_reject.include?(m[1])
-        else
-          false
-        end
-      end
-    end
-
-    # overwritten
-    def migration_storage_names
-      result = [::DatabaseCleaner::ActiveRecord::Base.migration_table_name]
-      result << ::ActiveRecord::Base.internal_metadata_table_name if ::ActiveRecord::VERSION::MAJOR >= 5
-      result
-    end
-
-    def cache_tables?
-      !!@cache_tables
-    end
-
-    def pre_count?
-      @pre_count == true
-    end
-
-    def reset_ids?
-      @reset_ids != false
-    end
-  end
-end