database_rewinder 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fba90991ea75253ed37624e82b4f6c26ae379f4c3b1d24a522192befb8529757
-  data.tar.gz: 70c3c776b0e291b49a873e503f4111cb537e9685479176527cd94de9a663cff2
+  metadata.gz: f8f897592605b10d934e9c74fd24476a6ef52e44e3292f0aa39caec97d2a65ba
+  data.tar.gz: 8c670decda9d1d418f8cf81c27ed3e47eb90fd17ac15e1f7d715f63623712e39
 SHA512:
-  metadata.gz: 457ed185619931c3aba3c9dd0b1a03b2156e712bfae655300d737bb1ac54ccc86a2d0256878ca7e765a2bd55e8798f6a855a9420eb5c2b8123cbd68b1298646b
-  data.tar.gz: ad40ddaa9b69d852a3001d60c6673dcd335a4171c7c77d05245b94f0c022a71a33bef1c323d7ddc6c1297498ea18ad52037ea78f8c17335a15d7a280fcf378a8
+  metadata.gz: 82d4794103447bebd78945eb398ec8ea37329827ac417a2b11a5bf39366cf4b71194b5c550f5d4dad36b54b3f491103660b7e261ec1ec9296fbf9f87b80c4a2b
+  data.tar.gz: 95e396cdc60bb54640890caf57f0c5c169544eb53171a8d060f23edde5837cec4cbd9f8c19892f01ec740a0f3d464188b14604b5043cf94371f771106a16a8d7

data/lib/database_rewinder/active_record_monkey.rb

@@ -4,7 +4,7 @@ module DatabaseRewinder
   module InsertRecorder
     # This method actually no longer has to be a `prepended` hook because InsertRecorder is a module without a direct method now, but still doing this just for compatibility
     def self.prepended(mod)
-      [:execute, :exec_query, :internal_exec_query].each do |method_name|
+      [:execute, :exec_insert, :exec_query, :internal_exec_query].each do |method_name|
         if mod.instance_methods.include?(method_name) && (meth = mod.instance_method(method_name))
           method_body = if meth.parameters.any? {|type, _name| [:key, :keyreq, :keyrest].include? type }
             <<-RUBY

data/lib/database_rewinder/cleaner.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require_relative 'lease_connection_compat'
 require_relative 'multiple_statements_executor'
 
+using DatabaseRewinder::LeaseConnectionCompat
 using DatabaseRewinder::MultipleStatementsExecutor
 
 module DatabaseRewinder
@@ -17,6 +19,10 @@ module DatabaseRewinder
       config['database']
     end
 
+    def host
+      config['host']
+    end
+
     def clean(multiple: true)
       return if !pool || inserted_tables.empty?
 
@@ -25,14 +31,14 @@ module DatabaseRewinder
       # In this case, we have to reconnect to the database to clean inserted
       # tables.
       with_automatic_reconnect(pool) do
-        delete_all (ar_conn = pool.connection), DatabaseRewinder.all_table_names(ar_conn) & inserted_tables, multiple: multiple
+        delete_all (ar_conn = pool.lease_connection), DatabaseRewinder.all_table_names(ar_conn) & inserted_tables, multiple: multiple
       end
       reset
     end
 
     def clean_all(multiple: true)
       if pool
-        ar_conn = pool.connection
+        ar_conn = pool.lease_connection
         delete_all ar_conn, DatabaseRewinder.all_table_names(ar_conn), multiple: multiple
       else
         require 'database_rewinder/dummy_model'

data/lib/database_rewinder/lease_connection_compat.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DatabaseRewinder
+  module LeaseConnectionCompat
+    # Make old AR compatible with AR >= 7.2 by defining `lease_connection`
+    unless ActiveRecord::ConnectionAdapters::ConnectionPool.instance_methods.include? :lease_connection
+      refine ActiveRecord::ConnectionAdapters::ConnectionPool do
+        def lease_connection
+          connection
+        end
+      end
+    end
+  end
+end

data/lib/database_rewinder/multiple_statements_executor.rb

@@ -12,18 +12,18 @@ module DatabaseRewinder
         #TODO Use ADAPTER_NAME when we've dropped AR 4.1 support
         case self.class.name
         when 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter'
-          disable_referential_integrity { log(sql) { (@raw_connection || @connection).exec sql } }
+          disable_referential_integrity { log(sql) { raw_connection_or_connection.exec sql } }
         when 'ActiveRecord::ConnectionAdapters::Mysql2Adapter'
-          if (@raw_connection || @connection).query_options[:connect_flags] & Mysql2::Client::MULTI_STATEMENTS != 0
+          if raw_connection_or_connection.query_options[:connect_flags] & Mysql2::Client::MULTI_STATEMENTS != 0
             disable_referential_integrity do
-              _result = log(sql) { (@raw_connection || @connection).query sql }
-              while (@raw_connection || @connection).next_result
+              _result = log(sql) { raw_connection_or_connection.query sql }
+              while raw_connection_or_connection.next_result
                 # just to make sure that all queries are finished
-                _result = (@raw_connection || @connection).store_result
+                _result = raw_connection_or_connection.store_result
               end
             end
           else
-            query_options = (@raw_connection || @connection).query_options.dup
+            query_options = raw_connection_or_connection.query_options.dup
             query_options[:connect_flags] |= Mysql2::Client::MULTI_STATEMENTS
             # opens another connection to the DB
             client = Mysql2::Client.new query_options
@@ -40,11 +40,17 @@ module DatabaseRewinder
             end
           end
         when 'ActiveRecord::ConnectionAdapters::SQLite3Adapter'
-          disable_referential_integrity { log(sql) { (@raw_connection || @connection).execute_batch sql } }
+          disable_referential_integrity { log(sql) { raw_connection_or_connection.execute_batch sql } }
         else
           raise 'Multiple deletion is not supported with the current database adapter.'
         end
       end
+
+      private
+
+      def raw_connection_or_connection
+        defined?(@raw_connection) ? @raw_connection : @connection
+      end
     end
   end
 end

data/lib/database_rewinder.rb

@@ -39,13 +39,14 @@ module DatabaseRewinder
     def record_inserted_table(connection, sql)
       config = connection.instance_variable_get(:'@config')
       database = config[:database]
+      host = config[:host]
       #NOTE What's the best way to get the app dir besides Rails.root? I know Dir.pwd here might not be the right solution, but it should work in most cases...
       root_dir = defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : Dir.pwd
       cleaner = cleaners.detect do |c|
         if (config[:adapter] == 'sqlite3') && (config[:database] != ':memory:')
           File.expand_path(c.db, root_dir) == File.expand_path(database, root_dir)
         else
-          c.db == database
+          c.db == database && c.host == host
         end
       end or return
 
@@ -78,10 +79,10 @@ module DatabaseRewinder
       cache_key = get_cache_key(connection.pool)
       #NOTE connection.tables warns on AR 5 with some adapters
       tables =
-        if Rails.application.respond_to?(:deprecators) # AR >= 7.1
-          Rails.application.deprecators.silence { connection.tables }
-        else
+        if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR == 0
           ActiveSupport::Deprecation.silence { connection.tables }
+        else
+          connection.tables
         end
       schema_migraion_table_name =
         if ActiveRecord::SchemaMigration.respond_to?(:table_name)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: database_rewinder
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Akira Matsuda
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-09 00:00:00.000000000 Z
+date: 2025-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,32 +72,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/main.yml"
-- ".gitignore"
-- Gemfile
 - MIT_LICENSE
 - README.md
-- Rakefile
-- database_rewinder.gemspec
 - lib/database_rewinder.rb
 - lib/database_rewinder/active_record_monkey.rb
 - lib/database_rewinder/cleaner.rb
 - lib/database_rewinder/compatibility.rb
 - lib/database_rewinder/dummy_model.rb
+- lib/database_rewinder/lease_connection_compat.rb
 - lib/database_rewinder/multiple_statements_executor.rb
 - lib/database_rewinder/railtie.rb
-- test/active_record_monkey_test.rb
-- test/cleaner_test.rb
-- test/config/database.yml
-- test/database_rewinder_test.rb
-- test/db/.keep
-- test/fake_app.rb
-- test/test_helper.rb
 homepage: https://github.com/amatsuda/database_rewinder
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -113,15 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.0.dev
-signing_key:
+rubygems_version: 3.7.0.dev
 specification_version: 4
 summary: A minimalist's tiny and ultra-fast database cleaner
-test_files:
-- test/active_record_monkey_test.rb
-- test/cleaner_test.rb
-- test/config/database.yml
-- test/database_rewinder_test.rb
-- test/db/.keep
-- test/fake_app.rb
-- test/test_helper.rb
+test_files: []

data/.github/workflows/main.yml

@@ -1,165 +0,0 @@
-name: build
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    services:
-      postgres:
-        image: postgres:12
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
-        ports:
-          - 5432:5432
-        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
-      mysql:
-        image: mysql:5.7
-        env:
-          MYSQL_ROOT_PASSWORD:
-          MYSQL_ALLOW_EMPTY_PASSWORD: 'yes'
-        ports:
-          - 3306:3306
-        options: --health-cmd "mysqladmin ping" --health-interval 10s --health-timeout 5s --health-retries 10
-
-    strategy:
-      fail-fast: false
-
-      matrix:
-        db: [sqlite3, postgresql, mysql]
-        ruby_version: [ruby-head, '3.3', '3.2', '3.1']
-        rails_version: [edge, '7.1', '7.0', '6.1']
-
-        exclude:
-          - ruby_version: ruby-head
-            rails_version: '6.1'
-
-        include:
-          - ruby_version: '3.0'
-            rails_version: '7.1'
-            db: sqlite3
-          - ruby_version: '3.0'
-            rails_version: '7.1'
-            db: postgresql
-          - ruby_version: '3.0'
-            rails_version: '7.1'
-            db: mysql
-
-          - ruby_version: '2.7'
-            rails_version: '7.1'
-            db: sqlite3
-          - ruby_version: '2.7'
-            rails_version: '7.1'
-            db: postgresql
-          - ruby_version: '2.7'
-            rails_version: '7.1'
-            db: mysql
-
-          - ruby_version: '2.7'
-            rails_version: '7.0'
-            db: sqlite3
-          - ruby_version: '2.7'
-            rails_version: '7.0'
-            db: postgresql
-          - ruby_version: '2.7'
-            rails_version: '7.0'
-            db: mysql
-
-          - ruby_version: '3.0'
-            rails_version: '6.1'
-            db: sqlite3
-          - ruby_version: '3.0'
-            rails_version: '6.1'
-            db: postgresql
-          - ruby_version: '3.0'
-            rails_version: '6.1'
-            db: mysql
-
-          - ruby_version: '2.6'
-            rails_version: '6.1'
-            db: sqlite3
-          - ruby_version: '2.6'
-            rails_version: '6.1'
-            db: postgresql
-          - ruby_version: '2.6'
-            rails_version: '6.1'
-            db: mysql
-
-          - ruby_version: '2.7'
-            rails_version: '6.0'
-            db: sqlite3
-          - ruby_version: '2.7'
-            rails_version: '6.0'
-            db: postgresql
-          - ruby_version: '2.7'
-            rails_version: '6.0'
-            db: mysql
-
-          - ruby_version: '2.7'
-            rails_version: '5.2'
-            db: sqlite3
-          - ruby_version: '2.7'
-            rails_version: '5.2'
-            db: postgresql
-          - ruby_version: '2.7'
-            rails_version: '5.2'
-            db: mysql
-          - ruby_version: '2.4'
-            rails_version: '5.2'
-            db: sqlite3
-          - ruby_version: '2.4'
-            rails_version: '5.2'
-            db: postgresql
-          - ruby_version: '2.4'
-            rails_version: '5.2'
-            db: mysql
-
-          - ruby_version: '2.6'
-            rails_version: '5.1'
-            db: sqlite3
-          - ruby_version: '2.6'
-            rails_version: '5.1'
-            db: postgresql
-          - ruby_version: '2.6'
-            rails_version: '5.1'
-            db: mysql
-
-          - ruby_version: '2.5'
-            rails_version: '5.0'
-            db: sqlite3
-          - ruby_version: '2.5'
-            rails_version: '5.0'
-            db: postgresql
-          - ruby_version: '2.5'
-            rails_version: '5.0'
-            db: mysql
-
-          - ruby_version: '2.4'
-            rails_version: '4.2'
-            db: sqlite3
-          - ruby_version: '2.4'
-            rails_version: '4.2'
-            db: postgresql
-          - ruby_version: '2.4'
-            rails_version: '4.2'
-            db: mysql
-
-    runs-on: ubuntu-20.04
-
-    env:
-      RAILS_VERSION: ${{ matrix.rails_version }}
-      DB: ${{ matrix.db }}
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby_version }}
-          rubygems: ${{ matrix.ruby_version < '2.6' && 'default' || 'latest' }}
-          bundler: ${{ startsWith(matrix.rails_version, '4.') && '1' || 'latest' }}
-          bundler-cache: true
-        continue-on-error: ${{ (matrix.ruby_version == 'ruby-head') || (matrix.allow_failures == 'true') }}
-
-      - run: bundle exec rake
-        continue-on-error: ${{ (matrix.ruby_version == 'ruby-head') || (matrix.rails_version == 'edge') || (matrix.allow_failures == 'true') }}

data/.gitignore

@@ -1,21 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-gemfiles/*.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-test/reports
-test/tmp
-test/version_tmp
-tmp
-log
-test/*.sqlite3
-test/db/*.sqlite3

data/Gemfile

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in database_rewinder.gemspec
-gemspec
-
-if ENV['RAILS_VERSION'] == 'edge'
-  gem 'rails', git: 'https://github.com/rails/rails.git'
-elsif ENV['RAILS_VERSION']
-  gem 'rails', "~> #{ENV['RAILS_VERSION']}.0"
-else
-  gem 'rails'
-end
-
-gem 'nokogiri', RUBY_VERSION < '2.1' ? '~> 1.6.0' : '>= 1.7'
-gem 'loofah', RUBY_VERSION < '2.5' ? '< 2.21.0' : '>= 0'
-gem 'selenium-webdriver'
-
-rails_version = ENV['RAILS_VERSION'] || '∞'
-
-case ENV['DB']
-when 'postgresql'
-  gem 'pg', rails_version <= '5.2' ? '~> 0.21' : '>= 1'
-when 'mysql'
-  if rails_version <= '4.1'
-    gem 'mysql2', '~> 0.3.13'
-  elsif rails_version <= '4.2'
-    gem 'mysql2', '~> 0.4.0'
-  else
-    gem 'mysql2'
-  end
-else
-  gem 'sqlite3', rails_version <= '5.0' ? '< 1.4' : '>= 1.4'
-end

data/Rakefile

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler'
-require 'bundler/setup'
-require "bundler/gem_tasks"
-require 'rake/testtask'
-
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.warning = true
-  t.verbose = true
-end
-
-task default: :test

data/database_rewinder.gemspec

@@ -1,27 +0,0 @@
-# coding: utf-8
-# frozen_string_literal: true
-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-Gem::Specification.new do |spec|
-  spec.name          = "database_rewinder"
-  spec.version       = '1.0.0'
-  spec.authors       = ["Akira Matsuda"]
-  spec.email         = ["ronnie@dio.jp"]
-  spec.description   = "A minimalist's tiny and ultra-fast database cleaner for Active Record"
-  spec.summary       = "A minimalist's tiny and ultra-fast database cleaner"
-  spec.homepage      = 'https://github.com/amatsuda/database_rewinder'
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency 'test-unit-rails'
-  spec.add_development_dependency 'rails'
-  spec.required_ruby_version = '>= 2.0.0'
-end

data/test/active_record_monkey_test.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class DatabaseRewinder::InsertRecorderTest < ActiveSupport::TestCase
-  setup do
-    DatabaseRewinder.init
-    Foo.create! name: 'foo1'
-    Bar.connection.execute "insert into bars (name) values ('bar1')"
-    DatabaseRewinder.cleaners
-  end
-
-  test '#execute' do
-    cleaner = DatabaseRewinder.instance_variable_get(:'@cleaners').detect {|c| c.db == (ENV['DB'] == 'sqlite3' ? 'db/database_rewinder_test.sqlite3' : 'database_rewinder_test')}
-
-    assert_equal %w(foos bars), cleaner.inserted_tables
-    assert_not_nil cleaner.pool
-  end
-end

data/test/cleaner_test.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class DatabaseRewinder::CleanerTest < ActiveSupport::TestCase
-  sub_test_case '#strategy=' do
-    setup { @cleaner = DatabaseRewinder::Cleaner.new(only: ['foos'], except: 'bars') }
-
-    test 'without options' do
-      @cleaner.strategy = :truncation
-
-      # it should keep instance variables
-      assert_equal ['foos'], @cleaner.instance_variable_get(:@only)
-      assert_equal ['bars'], @cleaner.instance_variable_get(:@except)
-    end
-
-    test 'with options (an array or a string)' do
-      @cleaner.strategy = :truncation, { only: ['bars'], except: 'bazs' }
-
-      # it should overwrite instance variables
-      assert_equal ['bars'], @cleaner.instance_variable_get(:@only)
-      assert_equal ['bazs'], @cleaner.instance_variable_get(:@except)
-    end
-
-    test 'with options (an empty array or nil)' do
-      @cleaner.strategy = :truncation, { only: [], except: nil }
-
-      # it should overwrite instance variables even if they are empty/nil
-      assert_equal [], @cleaner.instance_variable_get(:@only)
-      assert_equal [], @cleaner.instance_variable_get(:@except)
-    end
-  end
-end

data/test/config/database.yml

@@ -1,52 +0,0 @@
-<% case ENV['DB']
-   when 'sqlite3' %>
-test:
-  adapter: sqlite3
-  database: db/database_rewinder_test.sqlite3
-  pool: 5
-  timeout: 5000
-
-test2:
-  adapter: sqlite3
-  database: db/database_rewinder_test2.sqlite3
-  pool: 5
-  timeout: 5000
-
-<% when 'mysql' %>
-test:
-  adapter: mysql2
-  host: 127.0.0.1
-  username: root
-  password:
-  database: database_rewinder_test
-
-test2:
-  adapter: mysql2
-  host: 127.0.0.1
-  username: root
-  password:
-  database: database_rewinder_test2
-
-<% when 'postgresql' %>
-superuser_connection:
-  adapter: postgresql
-  host: localhost
-  # this user has to be a superuser for the tests to pass
-  username: postgres
-  password: postgres
-  database: postgres
-
-test:
-  adapter: postgresql
-  host: localhost
-  username: database_rewinder_user
-  password: postgres
-  database: database_rewinder_test
-
-test2:
-  adapter: postgresql
-  host: localhost
-  username: database_rewinder_user
-  password: postgres
-  database: database_rewinder_test2
-<% end %>

data/test/database_rewinder_test.rb

@@ -1,324 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class DatabaseRewinder::DatabaseRewinderTest < ActiveSupport::TestCase
-  if ActiveRecord::VERSION::MAJOR >= 5
-    self.use_transactional_tests = false
-  else
-    self.use_transactional_fixtures = false
-  end
-
-  setup do
-    DatabaseRewinder.init
-  end
-
-  sub_test_case '.[]' do
-    teardown do
-      DatabaseRewinder.database_configuration = nil
-    end
-    sub_test_case 'for connecting to an arbitrary database' do
-      def assert_cleaners_added(cleaner_names)
-        connection_names =  DatabaseRewinder.instance_variable_get(:'@cleaners').map {|c| c.connection_name}
-        yield
-        assert_equal cleaner_names, DatabaseRewinder.instance_variable_get(:'@cleaners').map {|c| c.connection_name} - connection_names
-      end
-
-      test 'simply giving a connection name only' do
-        assert_cleaners_added ['aaa'] do
-          DatabaseRewinder.database_configuration = {'aaa' => {'adapter' => 'sqlite3', 'database' => ':memory:'}}
-          DatabaseRewinder['aaa']
-        end
-      end
-
-      test 'giving a connection name via Hash with :connection key' do
-        assert_cleaners_added ['bbb'] do
-          DatabaseRewinder.database_configuration = {'bbb' => {'adapter' => 'sqlite3', 'database' => ':memory:'}}
-          DatabaseRewinder[connection: 'bbb']
-        end
-      end
-
-      test 'the Cleaner compatible syntax' do
-        assert_cleaners_added ['ccc'] do
-          DatabaseRewinder.database_configuration = {'ccc' => {'adapter' => 'sqlite3', 'database' => ':memory:'}}
-          DatabaseRewinder[:aho, connection: 'ccc']
-        end
-      end
-
-      if ActiveRecord::VERSION::MAJOR >= 6
-        sub_test_case 'with traditional configurations' do
-          test 'simply giving a connection name only' do
-            assert_cleaners_added ['aaa'] do
-              DatabaseRewinder.database_configuration = ActiveRecord::DatabaseConfigurations.new({'aaa' => {'adapter' => 'sqlite3', 'database' => ':memory:'}})
-              DatabaseRewinder['aaa']
-            end
-          end
-
-          test 'giving a connection name via Hash with :connection key' do
-            assert_cleaners_added ['bbb'] do
-              DatabaseRewinder.database_configuration = ActiveRecord::DatabaseConfigurations.new({'bbb' => {'adapter' => 'sqlite3', 'database' => ':memory:'}})
-              DatabaseRewinder[connection: 'bbb']
-            end
-          end
-
-          test 'the Cleaner compatible syntax' do
-            assert_cleaners_added ['ccc'] do
-              DatabaseRewinder.database_configuration = ActiveRecord::DatabaseConfigurations.new({'ccc' => {'adapter' => 'sqlite3', 'database' => ':memory:'}})
-              DatabaseRewinder[:aho, connection: 'ccc']
-            end
-          end
-        end
-
-        sub_test_case 'with multiple database configurations' do
-          test 'simply giving a connection name only' do
-            assert_cleaners_added ['aaa'] do
-              DatabaseRewinder.database_configuration = ActiveRecord::DatabaseConfigurations.new({'test' => {'aaa' => {'adapter' => 'sqlite3', 'database' => ':memory:'}}})
-              DatabaseRewinder['aaa']
-            end
-          end
-
-          test 'giving a connection name via Hash with :connection key' do
-            assert_cleaners_added ['bbb'] do
-              DatabaseRewinder.database_configuration = ActiveRecord::DatabaseConfigurations.new({'test' => {'bbb' => {'adapter' => 'sqlite3', 'database' => ':memory:'}}})
-              DatabaseRewinder[connection: 'bbb']
-            end
-          end
-
-          test 'the Cleaner compatible syntax' do
-            assert_cleaners_added ['ccc'] do
-              DatabaseRewinder.database_configuration = ActiveRecord::DatabaseConfigurations.new({'test' => {'ccc' => {'adapter' => 'sqlite3', 'database' => ':memory:'}}})
-              DatabaseRewinder[:aho, connection: 'ccc']
-            end
-          end
-        end
-      end
-    end
-
-    test 'for connecting to multiple databases' do
-      DatabaseRewinder[:active_record, connection: 'test']
-      DatabaseRewinder[:active_record, connection: 'test2']
-
-      Foo.create! name: 'foo1'
-      Quu.create! name: 'quu1'
-
-      DatabaseRewinder.clean
-
-      # it should clean all configured databases
-      assert_equal 0, Foo.count
-      assert_equal 0, Quu.count
-    end
-  end
-
-  sub_test_case '.record_inserted_table' do
-    setup do
-      DatabaseRewinder.cleaners
-    end
-
-    def perform_insert(sql)
-      @cleaner = DatabaseRewinder.instance_variable_get(:'@cleaners').detect {|c| c.db == (ENV['DB'] == 'sqlite3' ? 'db/database_rewinder_test.sqlite3' : 'database_rewinder_test')}
-
-      connection = ::ActiveRecord::Base.connection
-      DatabaseRewinder.record_inserted_table(connection, sql)
-    end
-    teardown do
-      DatabaseRewinder.database_configuration = nil
-    end
-
-    sub_test_case 'via General Active Record insertions' do
-      setup do
-        DatabaseRewinder.cleaners
-        @cleaner = DatabaseRewinder.instance_variable_get(:'@cleaners').detect {|c| c.db == (ENV['DB'] == 'sqlite3' ? 'db/database_rewinder_test.sqlite3' : 'database_rewinder_test')}
-      end
-
-      test 'create' do
-        Bar.create name: 'bar1'
-        assert_equal ['bars'], @cleaner.inserted_tables
-      end
-
-      if ActiveRecord::VERSION::MAJOR >= 6
-        test 'insert_all' do
-          Bar.insert_all! [{name: 'bar1'}]
-          assert_equal ['bars'], @cleaner.inserted_tables
-        end
-      end
-    end
-
-    sub_test_case 'common database' do
-      test 'include database name' do
-        perform_insert 'INSERT INTO "database"."foos" ("name") VALUES (?)'
-        assert_equal ['foos'], @cleaner.inserted_tables
-      end
-      test 'only table name' do
-        perform_insert 'INSERT INTO "foos" ("name") VALUES (?)'
-        assert_equal ['foos'], @cleaner.inserted_tables
-      end
-      test 'without "INTO"' do
-        perform_insert 'INSERT "foos" ("name") VALUES (?)'
-        assert_equal ['foos'], @cleaner.inserted_tables
-      end
-      test 'with space before "INSERT"' do
-        perform_insert <<-SQL
-          INSERT INTO "foos" ("name") VALUES (?)
-        SQL
-        assert_equal ['foos'], @cleaner.inserted_tables
-      end
-      test 'without spaces between table name and columns list' do
-        perform_insert 'INSERT INTO foos(name) VALUES (?)'
-        assert_equal ['foos'], @cleaner.inserted_tables
-      end
-
-      test 'with multi statement query' do
-        perform_insert <<-SQL
-          INSERT INTO "foos" ("name") VALUES (?);
-          INSERT INTO "bars" ("name") VALUES (?)
-        SQL
-        assert_equal ['foos', 'bars'], @cleaner.inserted_tables
-      end
-    end
-
-    sub_test_case 'Database accepts more than one dots in an object notation (e.g. SQLServer)' do
-      test 'full joined' do
-        perform_insert 'INSERT INTO server.database.schema.foos ("name") VALUES (?)'
-        assert_equal ['foos'], @cleaner.inserted_tables
-      end
-      test 'missing one' do
-        perform_insert 'INSERT INTO database..foos ("name") VALUES (?)'
-        assert_equal ['foos'], @cleaner.inserted_tables
-      end
-
-      test 'missing two' do
-        perform_insert 'INSERT INTO server...foos ("name") VALUES (?)'
-        assert_equal ['foos'], @cleaner.inserted_tables
-      end
-    end
-
-    test 'when database accepts INSERT IGNORE INTO statement' do
-      perform_insert "INSERT IGNORE INTO `foos` (`name`) VALUES ('alice'), ('bob') ON DUPLICATE KEY UPDATE `foos`.`updated_at`=VALUES(`updated_at`)"
-      assert_equal ['foos'], @cleaner.inserted_tables
-    end
-  end
-
-  test '.clean' do
-    bar = Bar.create! name: 'bar1'
-    Foo.create! name: 'foo1', bar_id: bar.id
-    DatabaseRewinder.clean
-
-    assert_equal 0, Foo.count
-    assert_equal 0, Bar.count
-  end
-
-  if ActiveRecord::VERSION::MAJOR >= 4
-    sub_test_case 'migrations' do
-      if ActiveRecord::VERSION::STRING >= '7.1'
-        test '.clean_all should not touch AR::SchemaMigration' do
-          schema_migration = ActiveRecord::SchemaMigration.new(ActiveRecord::Base.connection)
-          schema_migration.create_table
-
-          begin
-            schema_migration.create_version '001'
-            DatabaseRewinder.clean_all
-
-            assert_equal 0, Foo.count
-            assert_equal 1, schema_migration.count
-          ensure
-            schema_migration.drop_table
-          end
-        end
-      else
-        test '.clean_all should not touch AR::SchemaMigration' do
-          ActiveRecord::SchemaMigration.create_table
-
-          begin
-            ActiveRecord::SchemaMigration.create! version: '001'
-            DatabaseRewinder.clean_all
-
-            assert_equal 0, Foo.count
-            assert_equal 1, ActiveRecord::SchemaMigration.count
-          ensure
-            ActiveRecord::SchemaMigration.drop_table
-          end
-        end
-      end
-    end
-  end
-
-  sub_test_case '.clean_with' do
-    def perform_clean(options)
-      @cleaner = DatabaseRewinder.cleaners.first
-      @only = @cleaner.instance_variable_get(:@only)
-      @except = @cleaner.instance_variable_get(:@except)
-      Foo.create! name: 'foo1'
-      Bar.create! name: 'bar1'
-      DatabaseRewinder.clean_with :truncation, **options
-    end
-
-    test 'with only option' do
-      perform_clean only: ['foos']
-      assert_equal 0, Foo.count
-      assert_equal 1, Bar.count
-      assert_equal @only, @cleaner.instance_variable_get(:@only)
-    end
-
-    test 'with except option' do
-      perform_clean except: ['bars']
-      assert_equal 0, Foo.count
-      assert_equal 1, Bar.count
-      assert_equal @except, @cleaner.instance_variable_get(:@except)
-    end
-  end
-
-  sub_test_case '.cleaning' do
-    test 'without exception' do
-      DatabaseRewinder.cleaning do
-        Foo.create! name: 'foo1'
-      end
-
-      assert_equal 0, Foo.count
-    end
-
-    test 'with exception' do
-      assert_raises do
-        DatabaseRewinder.cleaning do
-          Foo.create! name: 'foo1'; fail
-        end
-      end
-      assert_equal 0, Foo.count
-    end
-  end
-
-  sub_test_case '.strategy=' do
-    sub_test_case 'call first with options' do
-      setup do
-        DatabaseRewinder.strategy = :truncate, { only: ['foos'], except: ['bars'] }
-      end
-
-      test 'should set options' do
-        assert_equal ['foos'], DatabaseRewinder.instance_variable_get(:@only)
-        assert_equal ['bars'], DatabaseRewinder.instance_variable_get(:@except)
-      end
-
-      test 'should create cleaner with options' do
-        cleaner = DatabaseRewinder.instance_variable_get(:@cleaners).first
-        assert_equal ['foos'], cleaner.instance_variable_get(:@only)
-        assert_equal ['bars'], cleaner.instance_variable_get(:@except)
-      end
-
-      sub_test_case 'call again with different options' do
-        setup do
-          DatabaseRewinder.strategy = :truncate, { only: ['bazs'], except: [] }
-        end
-
-        test 'should overwrite options' do
-          assert_equal ['bazs'], DatabaseRewinder.instance_variable_get(:@only)
-          assert_equal [], DatabaseRewinder.instance_variable_get(:@except)
-        end
-
-        test 'should overwrite cleaner with new options' do
-          cleaner = DatabaseRewinder.instance_variable_get(:@cleaners).first
-          assert_equal ['bazs'], cleaner.instance_variable_get(:@only)
-          assert_equal [], cleaner.instance_variable_get(:@except)
-        end
-      end
-    end
-  end
-end

data/test/fake_app.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-ENV['DB'] ||= 'sqlite3'
-require 'active_record/railtie'
-
-module DatabaseRewinderTestApp
-  Application = Class.new(Rails::Application) do
-    # Rais.root
-    config.root = __dir__
-
-    config.eager_load = false
-    config.active_support.deprecation = :log
-
-    rake_tasks do
-      load 'active_record/railties/databases.rake'
-    end
-  end.initialize!
-end
-
-require 'active_record/base'
-
-if ENV['DB'] == 'postgresql'
-  ActiveRecord::Base.establish_connection(:superuser_connection).connection.execute(<<-CREATE_ROLE_SQL)
-  DO
-  $do$
-  BEGIN
-    IF NOT EXISTS (SELECT FROM pg_catalog.pg_roles WHERE rolname = 'database_rewinder_user') THEN
-      CREATE ROLE database_rewinder_user LOGIN PASSWORD 'postgres' createdb;
-    END IF;
-  END
-  $do$
-CREATE_ROLE_SQL
-  ActiveRecord::Base.remove_connection
-end
-
-ActiveRecord::Tasks::DatabaseTasks.root ||= Rails.root
-ActiveRecord::Tasks::DatabaseTasks.drop_current 'test'
-ActiveRecord::Tasks::DatabaseTasks.drop_current 'test2'
-ActiveRecord::Tasks::DatabaseTasks.create_current 'test'
-ActiveRecord::Tasks::DatabaseTasks.create_current 'test2'
-
-# models
-class Foo < ActiveRecord::Base; end
-class Bar < ActiveRecord::Base; end
-class Baz < ActiveRecord::Base; end
-class Quu < ActiveRecord::Base
-  establish_connection :test2
-end
-
-# migrations
-class CreateAllTables < ActiveRecord::VERSION::MAJOR >= 5 ? ActiveRecord::Migration[5.0] : ActiveRecord::Migration
-  def self.up
-    ActiveRecord::Base.establish_connection :test
-    create_table(:bars) {|t| t.string :name; t.index :name, unique: true }
-    create_table(:foos) {|t| t.string :name; t.references :bar, foreign_key: true }
-    create_table(:bazs) {|t| t.string :name }
-
-    test2_connection = ActiveRecord::Base.establish_connection(:test2).connection
-    test2_connection.create_table(:quus) {|t| t.string :name }
-    ActiveRecord::Base.establish_connection :test
-  end
-
-  def self.down
-    drop_table(:foos) {|t| t.string :name }
-    drop_table(:bars) {|t| t.string :name }
-    drop_table(:bazs) {|t| t.string :name }
-
-    test2_connection = ActiveRecord::Base.establish_connection(:test2).connection
-    test2_connection.drop_table :quus
-    ActiveRecord::Base.establish_connection :test
-  end
-end

data/test/test_helper.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-ENV['RAILS_ENV'] ||= 'test'
-
-$LOAD_PATH.unshift(File.join(__dir__, '..', 'lib'))
-$LOAD_PATH.unshift(__dir__)
-
-require 'rails'
-require 'active_record'
-require 'database_rewinder'
-require 'fake_app'
-require 'test/unit/rails/test_help'
-begin
-  require 'selenium/webdriver'  # rails 6
-rescue LoadError
-end
-
-migrated = ActiveRecord::Base.connection.respond_to?(:data_source_exists?) ? ActiveRecord::Base.connection.data_source_exists?('foos') : ActiveRecord::Base.connection.table_exists?('foos')
-CreateAllTables.up unless migrated
-
-module DeleteAllTables
-  def teardown
-    super
-    [Foo, Bar, Baz, Quu].each {|m| m.delete_all }
-  end
-end
-ActiveSupport::TestCase.send :prepend, DeleteAllTables