database_cleaner-active_record 1.8.0.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f8d7d0428f1d0316620ed6aaf8d5053d7171e47f156fc806a79811a2eca9b91e
+  data.tar.gz: faa79553fe66d634d08557260827d88cd6463622903aae6192ec5126db8112a7
+SHA512:
+  metadata.gz: 33d786270e2e14441c98f79ad82bf226bb2a4d5a1fe95c777e32433ffb43edddbe4b17516eafc5aef70e557272201dd7997238ad99aa1af1960cb92257f0bbd7
+  data.tar.gz: d3c310d5f09216552da3ac9998cd8a2443610194fc3a8b0f3de2dc8cfd941bf8899b088231a65507c5f45b19767e65e83c6ab58bd5bd3416941e17be234ea7d6

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/spec/support/config.yml
+/tmp/
+!/tmp/.keep
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.9
+before_install: gem install bundler -v 1.17.2

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in database_cleaner-active_record.gemspec
+gemspec
+
+gem "database_cleaner", path: "../.."

data/Gemfile.lock

@@ -0,0 +1,73 @@
+PATH
+  remote: ../..
+  specs:
+    database_cleaner (1.8.0.beta)
+
+PATH
+  remote: .
+  specs:
+    database_cleaner-active_record (1.8.0.beta)
+      activerecord
+      database_cleaner (~> 1.8.0.beta)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.2.4.1)
+      activesupport (= 5.2.4.1)
+    activerecord (5.2.4.1)
+      activemodel (= 5.2.4.1)
+      activesupport (= 5.2.4.1)
+      arel (>= 9.0)
+    activerecord-mysql2-adapter (0.0.3)
+      mysql2
+    activesupport (5.2.4.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (9.0.0)
+    concurrent-ruby (1.1.5)
+    diff-lcs (1.3)
+    i18n (1.5.1)
+      concurrent-ruby (~> 1.0)
+    minitest (5.14.0)
+    mysql (2.9.1)
+    mysql2 (0.3.18)
+    pg (0.18.2)
+    rake (10.4.2)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    sqlite3 (1.3.10)
+    thread_safe (0.3.6)
+    tzinfo (1.2.6)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord-mysql2-adapter
+  bundler (~> 1.16)
+  database_cleaner!
+  database_cleaner-active_record!
+  mysql (~> 2.9.1)
+  mysql2
+  pg
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  sqlite3
+
+BUNDLED WITH
+   1.17.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2009 Ben Mabey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,110 @@
+# Database Cleaner Adapter for ActiveRecord
+
+[![Build Status](https://travis-ci.org/DatabaseCleaner/database_cleaner-active_record.svg?branch=master)](https://travis-ci.org/DatabaseCleaner/database_cleaner-active_record)
+[![Code Climate](https://codeclimate.com/github/DatabaseCleaner/database_cleaner-active_record/badges/gpa.svg)](https://codeclimate.com/github/DatabaseCleaner/database_cleaner-active_record)
+
+Clean your ActiveRecord databases with Database Cleaner.
+
+See https://github.com/DatabaseCleaner/database_cleaner for more information.
+
+## Installation
+
+```ruby
+# Gemfile
+group :test do
+  gem 'database_cleaner-active_record'
+end
+```
+
+## Supported Strategies
+
+Here is an overview of the supported strategies:
+
+<table>
+  <tbody>
+    <tr>
+      <th>Truncation</th>
+      <th>Transaction</th>
+      <th>Deletion</th>
+    </tr>
+    <tr>
+      <td> Yes</td>
+      <td> <b>Yes</b></td>
+      <td> Yes</td>
+    </tr>
+  </tbody>
+</table>
+
+(Default strategy is denoted in bold)
+
+For support or to discuss development please use the [Google Group](https://groups.google.com/group/database_cleaner).
+
+## What strategy is fastest?
+
+For the SQL libraries the fastest option will be to use `:transaction` as transactions are simply rolled back. If you can use this strategy you should. However, if you wind up needing to use multiple database connections in your tests (i.e. your tests run in a different process than your application) then using this strategy becomes a bit more difficult. You can get around the problem a number of ways.
+
+One common approach is to force all processes to use the same database connection ([common ActiveRecord hack](http://blog.plataformatec.com.br/2011/12/three-tips-to-improve-the-performance-of-your-test-suite/)) however this approach has been reported to result in non-deterministic failures.
+
+Another approach is to have the transactions rolled back in the application's process and relax the isolation level of the database (so the tests can read the uncommitted transactions).
+
+An easier, but slower, solution is to use the `:truncation` or `:deletion` strategy.
+
+So what is fastest out of `:deletion` and `:truncation`? Well, it depends on your table structure and what percentage of tables you populate in an average test. The reasoning is out of the scope of this README but here is a [good SO answer on this topic for Postgres](https://stackoverflow.com/questions/11419536/postgresql-truncation-speed/11423886#11423886).
+
+Some people report much faster speeds with `:deletion` while others say `:truncation` is faster for them. The best approach therefore is it try all options on your test suite and see what is faster.
+
+If you are using ActiveRecord then take a look at the [additional options](#additional-activerecord-options-for-truncation) available for `:truncation`.
+
+## Configuration options
+
+<table>
+  <tbody>
+    <tr>
+      <th>ORM</th>
+      <th>How to access</th>
+      <th>Notes</th>
+    </tr>
+    <tr>
+      <td> Active Record </td>
+      <td> <code>DatabaseCleaner[:active_record]</code></td>
+      <td> Connection specified as <code>:symbol</code> keys, loaded from <code>config/database.yml</code>. You may also pass in the ActiveRecord model under the <code>:model</code> key.</td>
+    </tr>
+  </tbody>
+</table>
+
+### Additional ActiveRecord options for Truncation
+
+The following options are available for ActiveRecord's `:truncation` strategy _only_ for MySQL and Postgres.
+
+* `:pre_count` - When set to `true` this will check each table for existing rows before truncating it.  This can speed up test suites when many of the tables to be truncated are never populated. Defaults to `:false`. (Also, see the section on [What strategy is fastest?](#what-strategy-is-fastest))
+* `:reset_ids` - This only matters when `:pre_count` is used, and it will make sure that a tables auto-incrementing id is reset even if there are no rows in the table (e.g. records were created in the test but also removed before DatabaseCleaner gets to it). Defaults to `true`.
+
+The following option is available for ActiveRecord's `:truncation` and `:deletion` strategy for any DB.
+
+* `:cache_tables` - When set to `true` the list of tables to truncate or delete from will only be read from the DB once, otherwise it will be read before each cleanup run. Set this to `false` if (1) you create and drop tables in your tests, or (2) you change Postgres schemas (`ActiveRecord::Base.connection.schema_search_path`) in your tests (for example, in a multitenancy setup with each tenant in a different Postgres schema). Defaults to `true`.
+
+
+## Common Errors
+
+### STDERR is being flooded when using Postgres
+
+If you are using Postgres and have foreign key constraints, the truncation strategy will cause a lot of extra noise to appear on STDERR (in the form of "NOTICE truncate cascades" messages).
+
+To silence these warnings set the following log level in your `postgresql.conf` file:
+
+```ruby
+client_min_messages = warning
+```
+
+For ActiveRecord, you add the following parameter in your database.yml file:
+
+<pre>
+test:
+  adapter: postgresql
+  # ...
+  min_messages: WARNING  
+</pre>
+
+## COPYRIGHT
+
+See [LICENSE] for details.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "database_cleaner/active_record"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle check || bundle install
+cp spec/support/sample.config.yml spec/support/config.yml
+

data/database_cleaner-active_record.gemspec

@@ -0,0 +1,40 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "database_cleaner/active_record/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "database_cleaner-active_record"
+  spec.version       = DatabaseCleaner::ActiveRecord::VERSION
+  spec.authors       = ["Ernesto Tagwerker"]
+  spec.email         = ["ernesto@ombulabs.com"]
+
+  spec.summary       = "Strategies for cleaning databases using ActiveRecord. Can be used to ensure a clean state for testing."
+  spec.description   = "Strategies for cleaning databases using ActiveRecord. Can be used to ensure a clean state for testing."
+  spec.homepage      = "https://github.com/DatabaseCleaner/database_cleaner-active_record"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "database_cleaner", "~> 1.8.0.beta"
+  spec.add_dependency "activerecord"
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  unless RUBY_PLATFORM =~ /java/
+    spec.add_development_dependency 'mysql', '~> 2.9.1'
+    spec.add_development_dependency 'mysql2'
+    spec.add_development_dependency "activerecord-mysql2-adapter"
+    spec.add_development_dependency 'pg'
+    spec.add_development_dependency "sqlite3"
+  else
+    spec.add_development_dependency "activerecord-jdbc-adapter"
+  end
+end

data/lib/database_cleaner-active_record.rb

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

data/lib/database_cleaner/active_record.rb

@@ -0,0 +1,6 @@
+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/lib/database_cleaner/active_record/base.rb

@@ -0,0 +1,101 @@
+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/lib/database_cleaner/active_record/deletion.rb

@@ -0,0 +1,108 @@
+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/lib/database_cleaner/active_record/transaction.rb

@@ -0,0 +1,59 @@
+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/lib/database_cleaner/active_record/truncation.rb

@@ -0,0 +1,278 @@
+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
+      [::DatabaseCleaner::ActiveRecord::Base.migration_table_name]
+    end
+
+    def cache_tables?
+      !!@cache_tables
+    end
+
+    def pre_count?
+      @pre_count == true
+    end
+
+    def reset_ids?
+      @reset_ids != false
+    end
+  end
+end

data/lib/database_cleaner/active_record/version.rb

@@ -0,0 +1,5 @@
+module DatabaseCleaner
+  module ActiveRecord
+    VERSION = "1.8.0.beta"
+  end
+end

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification
+name: database_cleaner-active_record
+version: !ruby/object:Gem::Version
+  version: 1.8.0.beta
+platform: ruby
+authors:
+- Ernesto Tagwerker
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0.beta
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0.beta
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: mysql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.1
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-mysql2-adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Strategies for cleaning databases using ActiveRecord. Can be used to
+  ensure a clean state for testing.
+email:
+- ernesto@ombulabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- database_cleaner-active_record.gemspec
+- lib/database_cleaner-active_record.rb
+- lib/database_cleaner/active_record.rb
+- lib/database_cleaner/active_record/base.rb
+- lib/database_cleaner/active_record/deletion.rb
+- lib/database_cleaner/active_record/transaction.rb
+- lib/database_cleaner/active_record/truncation.rb
+- lib/database_cleaner/active_record/version.rb
+- tmp/.keep
+homepage: https://github.com/DatabaseCleaner/database_cleaner-active_record
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Strategies for cleaning databases using ActiveRecord. Can be used to ensure
+  a clean state for testing.
+test_files: []