database_cleaner-active_record 1.99.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db0629196991321d7ca040c181f5e10feffb27a307c0db0f3a0aeaced412eaaa
-  data.tar.gz: 1b298eeb459d1903cba80e1031b5bbd24ea146fe6d4ad8ed2d4eeb93eb6cf254
+  metadata.gz: e2c9c7514dc1bea223af68a8a3822b1fb07e227911897166432f6018ab5b23a9
+  data.tar.gz: b3217f7ad1128617b17be1872207df59317204aa7912bca0a00e0aab77490d15
 SHA512:
-  metadata.gz: 69e20a7c75b34cadff9745bafae326a3d160cf285d9f2c37f4078363ceb9e88976cd22a3cc8f8789815f79843aa42c7b70b0549236447829377adc3af28e7e67
-  data.tar.gz: d7a27c45270537e4d72a09e8a1c23f95931f6bd1aec979aa9bba1318eab9a64e4395fc36398bdd8a77b0173b8d7c5cace9e42d68f351cd1e9249c5c330545f79
+  metadata.gz: 74e5baa1c2eb6de6b39213d9d192dcb649ff069d8ac5a9ad3d9347beb40b68a15c29a16149e2338098d246db3fdb6a7a22baef9911f4be5fb1954560d87e2b81
+  data.tar.gz: 991af4358084057df8efd4a05d7fa0eb75756ee8f940a7f2bd2e2da2a65a64a1bd96f668c355948e16b04c33b407276d2076f5bec5b47631e6682dd0a5221408

data/.gitignore

@@ -8,6 +8,11 @@
 /spec/support/config.yml
 /tmp/
 !/tmp/.keep
+/.ruby-version
+/.byebug_history
 
 # rspec failure tracking
 .rspec_status
+
+/Gemfile.lock
+/gemfiles/*.lock

data/.travis.yml

@@ -1,4 +1,17 @@
 language: ruby
+services:
+  - mysql
+  - postgresql
 rvm:
-  - 2.2.9
-before_install: gem install bundler -v 1.17.2
+  - 2.5
+  - 2.6
+  - 2.7
+gemfile:
+  - gemfiles/rails_5.1.gemfile
+  - gemfiles/rails_5.2.gemfile
+  - gemfiles/rails_6.0.gemfile
+  - gemfiles/rails_6.1.gemfile
+before_install:
+  - bin/setup
+cache:
+  bundler: true

data/Appraisals

@@ -0,0 +1,15 @@
+appraise "rails-5.1" do
+  gem "rails", "~>5.1.0"
+end
+
+appraise "rails-5.2" do
+  gem "rails", "~>5.2.0"
+end
+
+appraise "rails-6.0" do
+  gem "rails", "~>6.0.0"
+end
+
+appraise "rails-6.1" do
+  gem "rails", "~>6.1.0"
+end

data/Gemfile

@@ -1,8 +1,13 @@
 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: "../.."
+gem "database_cleaner-core", git: "https://github.com/DatabaseCleaner/database_cleaner"
+
+gem "rails", "~>5.2"
+gem "byebug"
+
+group :test do
+  gem "simplecov", require: false
+  gem "codecov", require: false
+end

data/README.md

@@ -2,11 +2,14 @@
 
 [![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)
+[![codecov](https://codecov.io/gh/DatabaseCleaner/database_cleaner-active_record/branch/master/graph/badge.svg)](https://codecov.io/gh/DatabaseCleaner/database_cleaner-active_record)
 
 Clean your ActiveRecord databases with Database Cleaner.
 
 See https://github.com/DatabaseCleaner/database_cleaner for more information.
 
+For support or to discuss development please use the [Google Group](https://groups.google.com/group/database_cleaner).
+
 ## Installation
 
 ```ruby
@@ -18,26 +21,11 @@ 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)
+Three strategies are supported:
 
-For support or to discuss development please use the [Google Group](https://groups.google.com/group/database_cleaner).
+* Transaction (default)
+* Truncation
+* Deletion
 
 ## What strategy is fastest?
 
@@ -53,36 +41,41 @@ So what is fastest out of `:deletion` and `:truncation`? Well, it depends on you
 
 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`.
+## Strategy configuration options
 
-## Configuration options
+The transaction strategy accepts no 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>
+The truncation and deletion strategies may accept the following options:
 
-### Additional ActiveRecord options for Truncation
+* `:only` and `:except` may take a list of table names:
 
-The following options are available for ActiveRecord's `:truncation` strategy _only_ for MySQL and Postgres.
+```ruby
+# Only truncate the "users" table.
+DatabaseCleaner[:active_record].strategy = :truncation, { only: ["users"] }
 
-* `: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`.
+# Delete all tables except the "users" table.
+DatabaseCleaner[:active_record].strategy = :deletion, { except: ["users"] }
+```
 
-The following option is available for ActiveRecord's `:truncation` and `:deletion` strategy for any DB.
+* `:pre_count` - When set to `true` this will check each table for existing rows before truncating or deleting it.  This can speed up test suites when many of the tables are never populated. Defaults to `false`. (Also, see the section on [What strategy is fastest?](#what-strategy-is-fastest))
 
 * `: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`.
 
+## Adapter configuration options
+
+`#db` defaults to the default ActiveRecord database, but can be specified manually in a few ways:
+
+```ruby
+# ActiveRecord connection key
+DatabaseCleaner[:active_record].db = :logs
+
+# Back to default:
+DatabaseCleaner[:active_record].db = :default
+
+# Multiple databases can be specified:
+DatabaseCleaner[:active_record, db: :default]
+DatabaseCleaner[:active_record, db: :logs]
+```
 
 ## Common Errors
 
@@ -92,11 +85,11 @@ If you are using Postgres and have foreign key constraints, the truncation strat
 
 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:
+You can also add this parameter to your database.yml file:
 
 <pre>
 test:
@@ -107,4 +100,4 @@ test:
 
 ## COPYRIGHT
 
-See [LICENSE] for details.
+See [LICENSE](LICENSE) for details.

data/bin/setup

@@ -5,4 +5,3 @@ set -vx
 
 bundle check || bundle install
 cp spec/support/sample.config.yml spec/support/config.yml
-

data/database_cleaner-active_record.gemspec

@@ -1,12 +1,9 @@
-
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "database_cleaner/active_record/version"
+require_relative "./lib/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.authors       = ["Ernesto Tagwerker", "Micah Geisel"]
   spec.email         = ["ernesto@ombulabs.com"]
 
   spec.summary       = "Strategies for cleaning databases using ActiveRecord. Can be used to ensure a clean state for testing."
@@ -21,20 +18,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "database_cleaner", "~> 1.99.0"
-  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"
+  spec.add_dependency "database_cleaner-core", "~>2.0.0"
+  spec.add_dependency "activerecord", ">= 5.a"
 
-  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
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "mysql2"
+  spec.add_development_dependency "pg"
+  spec.add_development_dependency "sqlite3"
 end

data/gemfiles/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_RETRY: "1"

data/gemfiles/rails_5.1.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "database_cleaner-core", git: "https://github.com/DatabaseCleaner/database_cleaner"
+gem "rails", "~>5.1.0"
+gem "byebug"
+
+group :test do
+  gem "simplecov", require: false
+  gem "codecov", require: false
+end
+
+gemspec path: "../"

data/gemfiles/rails_5.2.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "database_cleaner-core", git: "https://github.com/DatabaseCleaner/database_cleaner"
+gem "rails", "~>5.2.0"
+gem "byebug"
+
+group :test do
+  gem "simplecov", require: false
+  gem "codecov", require: false
+end
+
+gemspec path: "../"

data/gemfiles/rails_6.0.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "database_cleaner-core", git: "https://github.com/DatabaseCleaner/database_cleaner"
+gem "rails", "~>6.0.0"
+gem "byebug"
+
+group :test do
+  gem "simplecov", require: false
+  gem "codecov", require: false
+end
+
+gemspec path: "../"

data/gemfiles/rails_6.1.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "database_cleaner-core", git: "https://github.com/DatabaseCleaner/database_cleaner"
+gem "rails", "~>6.1.0"
+gem "byebug"
+
+group :test do
+  gem "simplecov", require: false
+  gem "codecov", require: false
+end
+
+gemspec path: "../"

data/lib/database_cleaner/active_record/base.rb

@@ -1,94 +1,76 @@
 require 'active_record'
-require 'database_cleaner/generic/base'
+require 'database_cleaner/strategy'
 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
+      @config_file_location ||= "#{Dir.pwd}/config/database.yml"
     end
 
-    module Base
-      include ::DatabaseCleaner::Generic::Base
-
-      attr_accessor :connection_hash
-
-      def db=(desired_db)
-        @db = desired_db
-        load_config
+    class Base < DatabaseCleaner::Strategy
+      def self.migration_table_name
+        ::ActiveRecord::SchemaMigration.table_name
       end
 
-      def db
-        @db ||= super
+      def self.exclusion_condition(column_name)
+        <<~SQL
+          #{column_name} <> '#{DatabaseCleaner::ActiveRecord::Base.migration_table_name}'
+            AND #{column_name} <> '#{::ActiveRecord::Base.internal_metadata_table_name}'
+        SQL
       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
+      def db=(*)
+        super
+        load_config
       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
+      attr_accessor :connection_hash
 
       def connection_class
         @connection_class ||= if db && !db.is_a?(Symbol)
                                 db
                               elsif connection_hash
-                                lookup_from_connection_pool || establish_connection
+                                (lookup_from_connection_pool rescue nil) || 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
+      private
+
+      def load_config
+        if db != :default && db.is_a?(Symbol) && File.file?(DatabaseCleaner::ActiveRecord.config_file_location)
+          connection_details = YAML::load(ERB.new(IO.read(DatabaseCleaner::ActiveRecord.config_file_location)).result)
+          @connection_hash   = valid_config(connection_details, db.to_s)
         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
+      def valid_config(connection_file, db)
+        return connection_file[db] unless (active_record_config_hash = active_record_config_hash_for(db))
+
+        active_record_config_hash
       end
 
-      private
+      def active_record_config_hash_for(db)
+        if ::ActiveRecord.version >= Gem::Version.new('6.1')
+          ::ActiveRecord::Base.configurations&.configs_for(name: db)&.configuration_hash
+        else
+          ::ActiveRecord::Base.configurations[db]
+        end
+      end
 
       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 }
+        return unless ::ActiveRecord::Base.respond_to?(:descendants)
+
+        database_name = connection_hash['database'] || connection_hash[:database]
+        ::ActiveRecord::Base.descendants.select(&:connection_pool).detect do |model|
+          database_for(model) == database_name
         end
       end
 
@@ -96,6 +78,14 @@ module DatabaseCleaner
         ::ActiveRecord::Base.establish_connection(connection_hash)
         ::ActiveRecord::Base
       end
+
+      def database_for(model)
+        if model.connection_pool.respond_to?(:db_config) # ActiveRecord >= 6.1
+          model.connection_pool.db_config.configuration_hash[:database]
+        else
+          model.connection_pool.spec.config[:database]
+        end
+      end
     end
   end
 end

data/lib/database_cleaner/active_record/deletion.rb

@@ -1,107 +1,70 @@
 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
+  module ActiveRecord
+    class Deletion < Truncation
+      def clean
+        connection.disable_referential_integrity do
+          if pre_count? && connection.respond_to?(:pre_count_tables)
+            delete_tables(connection, connection.pre_count_tables(tables_to_truncate(connection)))
+          else
+            delete_tables(connection, tables_to_truncate(connection))
+          end
+        end
       end
-    end
 
-    module GenericDeleteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
+      private
 
-    module OracleDeleteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)}")
+      def delete_tables(connection, table_names)
+        table_names.each do |table_name|
+          delete_table(connection, table_name)
+        end
       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
+      def delete_table connection, table_name
+        connection.execute("DELETE FROM #{connection.quote_table_name(table_name)}")
       end
-    end
 
-    def tables_with_new_rows(connection)
-      stats = table_stats_query(connection)
-      if stats != ''
-        connection.select_values(stats)
-      else
-        []
+      def tables_to_truncate(connection)
+        if information_schema_exists?(connection)
+          @except += connection.database_cleaner_view_cache + migration_storage_names
+          (@only.any? ? @only : tables_with_new_rows(connection)) - @except
+        else
+          super
+        end
       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 tables_with_new_rows(connection)
+        stats = table_stats_query(connection)
+        if stats != ''
+          connection.select_values(stats)
+        else
+          []
+        end
+      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)"
+      def table_stats_query(connection)
+        @table_stats_query ||= build_table_stats_query(connection)
+      ensure
+        @table_stats_query = nil unless @cache_tables
       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
+      def build_table_stats_query(connection)
+        tables = connection.select_values(<<-SQL)
+          SELECT table_name
+          FROM information_schema.tables
+          WHERE table_schema = database()
+          AND #{self.class.exclusion_condition('table_name')};
+        SQL
+        queries = tables.map do |table|
+          "(SELECT #{connection.quote(table)} FROM #{connection.quote_table_name(table)} LIMIT 1)"
         end
-    end
-  end
-
-  class Deletion < Truncation
-    if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
-      include SelectiveTruncation
-    end
+        queries.join(' UNION ALL ')
+      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
+      def information_schema_exists? connection
+        connection.adapter_name == "Mysql2"
       end
     end
   end