test-prof 0.12.2 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 796e133e85e58fec13b94d1dd51c3c9c934e122d04470115ef15788916a55d0b
-  data.tar.gz: a8519944d9f36a9a74371b6a9fc19e69ecfbd1155679f178a3d6b6a62425dff3
+  metadata.gz: b43e971bbd8c55a38c657e3338dc625d5860bd067e96385f310885024a1c5cc5
+  data.tar.gz: 6d4b767d0ed366be1b27521e986785b6ddfa9f2008eb9640c76baae55084bb34
 SHA512:
-  metadata.gz: ca5c8984a8ca9c4b2051be517bb462f8f0b9ba8ac582dd9cb74abeee81a98869400cbdf4e54e446de27215674bf0c90fe3b4dbeefdba620a1c5c67ff4a0ea0ce
-  data.tar.gz: 4591aadd9f5616d939f7e9fcf91e4b8f635f921722bbed4225b8094cd78f7e557efbf3c58e45a0ebac18acf02f5744697e87a46524081124ebf15c0232dd2e08
+  metadata.gz: 1b490801a31def008b6e8c77dff834e67c4c27a96d9d09fbe626dbed0009cb541da48acc7308905f3f8b722e8fc6f6bde39ebce5362e928abb0c2d319f259248
+  data.tar.gz: 825b2ca0cd5f0c4ea235c5df11686a39799a70685a1ae0911facceb383facec815bed04322336ec67867b51e3a0152d150ed9fe7db9f01bb1acea520fd095258

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## master (unrealeased)
 
+## 1.0.0.rc1 (2020-12-30)
+
+- Remove deprecated `AggregateFailures` cop. ([@palkan][])
+
+- Remove `ActiveRecordSharedConnection`. ([@palkan][])
+
+- Add `AnyFixture#register_dump` to _cache_ fixtures using SQL dumps. ([@palkan][])
+
+- Replaced `TestProf::AnyFixture.reporting_enabled = true` with `TestProf::AnyFixture.config.reporting_enabled = true`. ([@palkan][])
+
+- Add support for RSpec aliases detection when linting specs using `let_it_be`/`before_all` with `rubocop-rspec` 2.0 ([@pirj][])
+
 ## 0.12.2 (2020-09-03)
 
 - Execute Minitest `before_all` in the context of the current test object. ([@palkan][])

data/config/default.yml

@@ -18,18 +18,3 @@ RSpec/AggregateExamples:
     - validate_length_of
     - validate_inclusion_of
     - validates_exclusion_of
-
-# TODO: remove this one we hit 1.0
-RSpec/AggregateFailures:
-  Description: Checks if example group contains two or more aggregatable examples.
-  Enabled: false
-  StyleGuide: https://rspec.rubystyle.guide/#expectation-per-example
-  AddAggregateFailuresMetadata: true
-  MatchersWithSideEffects:
-    - allow_value
-    - allow_values
-    - validate_presence_of
-    - validate_absence_of
-    - validate_length_of
-    - validate_inclusion_of
-    - validates_exclusion_of

data/config/rubocop-rspec.yml

@@ -0,0 +1,6 @@
+RSpec:
+  Language:
+    Helpers:
+      - let_it_be
+    Hooks:
+      - before_all

data/lib/test_prof/any_fixture.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "test_prof/ext/float_duration"
+require "test_prof/any_fixture/dump"
 
 module TestProf
   # Make DB fixtures from blocks.
@@ -9,6 +10,58 @@ module TestProf
 
     using FloatDuration
 
+    # AnyFixture configuration
+    class Configuration
+      attr_accessor :reporting_enabled, :dumps_dir, :dump_sequence_start,
+        :import_dump_via_cli, :dump_matching_queries, :force_matching_dumps
+      attr_reader :default_dump_watch_paths
+
+      alias reporting_enabled? reporting_enabled
+      alias import_dump_via_cli? import_dump_via_cli
+
+      def initialize
+        @reporting_enabled = ENV["ANYFIXTURE_REPORT"] == "1"
+        @dumps_dir = "any_dumps"
+        @default_dump_watch_paths = %w[
+          db/schema.rb
+          db/structure.sql
+        ]
+        @dump_sequence_start = 123_654
+        @dump_matching_queries = /^$/
+        @import_dump_via_cli = ENV["ANYFIXTURE_IMPORT_DUMP_CLI"] == "1"
+        @before_dump = []
+        @after_dump = []
+        @force_matching_dumps =
+          if ENV["ANYFIXTURE_FORCE_DUMP"] == "1"
+            /.*/
+          elsif ENV["ANYFIXTURE_FORCE_DUMP"]
+            /#{ENV["ANYFIXTURE_FORCE_DUMP"]}/
+          else
+            /^$/
+          end
+      end
+
+      def before_dump(&block)
+        if block_given?
+          @before_dump << block
+        else
+          @before_dump
+        end
+      end
+
+      def after_dump(&block)
+        if block_given?
+          @after_dump << block
+        else
+          @after_dump
+        end
+      end
+
+      def dump_sequence_random_start
+        rand(dump_sequence_start..(dump_sequence_start * 2))
+      end
+    end
+
     class Cache # :nodoc:
       attr_reader :store, :stats
 
@@ -40,22 +93,74 @@ module TestProf
     class << self
       include Logging
 
-      attr_accessor :reporting_enabled
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
+      # Backward compatibility
+      def reporting_enabled=(val)
+        warn "AnyFixture.reporting_enabled is deprecated and will be removed in 1.1. Use AnyFixture.config.reporting_enabled instead"
+        config.reporting_enabled = val
+      end
 
-      def reporting_enabled?
-        reporting_enabled == true
+      def reporting_enabled
+        warn "AnyFixture.reporting_enabled is deprecated and will be removed in 1.1. Use AnyFixture.config.reporting_enabled instead"
+        config.reporting_enabled
       end
 
+      alias reporting_enabled? reporting_enabled
+
       # Register a block of code as a fixture,
       # returns the result of the block execution
       def register(id)
-        cache.fetch(id) do
+        cached(id) do
           ActiveSupport::Notifications.subscribed(method(:subscriber), "sql.active_record") do
             yield
           end
         end
       end
 
+      def cached(id)
+        cache.fetch(id) { yield }
+      end
+
+      # Create and register new SQL dump.
+      # Use `watch` to provide additional paths to watch for
+      # dump re-generation
+      def register_dump(name, clean: true, **options)
+        called_from = caller_locations(1, 1).first.path
+        watch = options.delete(:watch) || [called_from]
+        cache_key = options.delete(:cache_key)
+        skip = options.delete(:skip_if)
+
+        id = "sql/#{name}"
+
+        register_method = clean ? :register : :cached
+
+        public_send(register_method, id) do
+          dump = Dump.new(name, watch: watch, cache_key: cache_key)
+
+          unless dump.force?
+            next if skip&.call(dump: dump)
+
+            next dump.within_prepared_env(import: true, **options) { dump.load } if dump.exists?
+          end
+
+          subscriber = ActiveSupport::Notifications.subscribe("sql.active_record", dump.subscriber)
+          res = dump.within_prepared_env(**options) { yield }
+
+          dump.commit!
+
+          res
+        ensure
+          ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+        end
+      end
+
       # Clean all affected tables (but do not reset cache)
       def clean
         disable_referential_integrity do
@@ -76,7 +181,13 @@ module TestProf
 
       def subscriber(_event, _start, _finish, _id, data)
         matches = data.fetch(:sql).match(INSERT_RXP)
-        tables_cache[matches[1]] = true if matches
+        return unless matches
+
+        table_name = matches[1]
+
+        return if /sqlite_sequence/.match?(table_name)
+
+        tables_cache[table_name] = true
       end
 
       def report_stats
@@ -148,7 +259,5 @@ module TestProf
         connection.disable_referential_integrity { yield }
       end
     end
-
-    self.reporting_enabled = ENV["ANYFIXTURE_REPORT"] == "1"
   end
 end

data/lib/test_prof/any_fixture/dump.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "test_prof/any_fixture/dump/digest"
+
+require "set"
+
+module TestProf
+  module AnyFixture
+    MODIFY_RXP = /^(INSERT INTO|UPDATE|DELETE FROM) ([\S]+)/i.freeze
+    ANY_FIXTURE_RXP = /(\/\*|\-\-).*\bany_fixture:dump/.freeze
+    ANY_FIXTURE_IGNORE_RXP = /(\/\*|\-\-).*\bany_fixture:ignore/.freeze
+
+    using(Module.new do
+      refine Object do
+        def to_digest
+          to_s
+        end
+      end
+
+      refine NilClass do
+        def to_digest
+          nil
+        end
+      end
+
+      refine Hash do
+        def to_digest
+          map { |k, v| [k.to_digest, v.to_digest].compact.join("_") }
+        end
+      end
+
+      refine Array do
+        def to_digest
+          map { |v| v.to_digest }.compact.join("-")
+        end
+      end
+    end)
+
+    class Dump
+      class Subscriber
+        attr_reader :path, :tmp_path
+
+        def initialize(path, adapter)
+          @path = path
+          @adapter = adapter
+          @tmp_path = path + ".tmp"
+          @reset_pk = Set.new
+          @file = File.open(tmp_path, "w")
+        end
+
+        def start(_event, _id, payload)
+          sql = payload.fetch(:sql)
+          return if sql.match?(ANY_FIXTURE_IGNORE_RXP)
+
+          matches = sql.match(MODIFY_RXP)
+          return unless matches
+
+          reset_pk!(matches[2]) if /insert/i.match?(matches[1])
+        end
+
+        def finish(_event, _id, payload)
+          sql = payload.fetch(:sql)
+          return unless trackable_sql?(sql)
+
+          sql = payload[:binds].any? ? adapter.compile_sql(sql, quoted(payload[:binds])) : +sql
+
+          sql.tr!("\n", " ")
+
+          file.write(sql + ";\n")
+        end
+
+        def commit
+          file.close
+
+          FileUtils.mv(tmp_path, path)
+        end
+
+        private
+
+        attr_reader :file, :reset_pk, :adapter
+
+        def reset_pk!(table_name)
+          return if /sqlite_sequence/.match?(table_name)
+
+          return if reset_pk.include?(table_name)
+
+          adapter.reset_sequence!(table_name, AnyFixture.config.dump_sequence_random_start)
+          reset_pk << table_name
+        end
+
+        def trackable_sql?(sql)
+          return false if sql.match?(ANY_FIXTURE_IGNORE_RXP)
+
+          sql.match?(MODIFY_RXP) || sql.match?(ANY_FIXTURE_RXP) || sql.match?(AnyFixture.config.dump_matching_queries)
+        end
+
+        def quoted(val)
+          if val.is_a?(Array)
+            val.map { |v| quoted(v) }
+          elsif val.is_a?(ActiveRecord::Relation::QueryAttribute)
+            quoted(val.value_for_database)
+          else
+            ActiveRecord::Base.connection.quote(val)
+          end
+        end
+      end
+
+      attr_reader :name, :digest, :path, :subscriber, :success
+      alias success? success
+
+      def initialize(name, watch: [], cache_key: nil)
+        @name = name
+        @digest = [
+          Digest.call(*watch),
+          cache_key.to_digest
+        ].compact.join("-")
+
+        @path = build_path(name, digest)
+
+        @success = false
+
+        @adapter =
+          case ActiveRecord::Base.connection.adapter_name
+          when /sqlite/i
+            require "test_prof/any_fixture/dump/sqlite"
+            SQLite.new
+          when /postgresql/i
+            require "test_prof/any_fixture/dump/postgresql"
+            PostgreSQL.new
+          else
+            raise ArgumentError,
+              "Your current database adapter (#{ActiveRecord::Base.connection.adapter_name}) " \
+              "is currently not supported. So far, we only support SQLite and PostgreSQL"
+          end
+
+        @subscriber = Subscriber.new(path, adapter)
+      end
+
+      def exists?
+        File.exist?(path)
+      end
+
+      def force?
+        AnyFixture.config.force_matching_dumps.match?(name)
+      end
+
+      def load
+        return import_via_active_record unless AnyFixture.config.import_dump_via_cli?
+
+        adapter.import(path) || import_via_active_record
+      end
+
+      def commit!
+        subscriber.commit
+      end
+
+      def within_prepared_env(before: nil, after: nil, import: false)
+        run_before_callbacks(callback: before, dump: self, import: false)
+        yield.tap do
+          @success = true
+        end
+      ensure
+        run_after_callbacks(callback: after, dump: self, import: false)
+      end
+
+      private
+
+      attr_reader :adapter
+
+      def import_via_active_record
+        conn = ActiveRecord::Base.connection
+
+        File.open(path).each_line do |query|
+          next if query.empty?
+
+          conn.execute query
+        end
+      end
+
+      def build_path(name, digest)
+        dir = TestProf.artifact_path(
+          File.join(AnyFixture.config.dumps_dir)
+        )
+
+        FileUtils.mkdir_p(dir)
+
+        File.join(dir, "#{name}-#{digest}.sql")
+      end
+
+      def run_before_callbacks(callback:, **options)
+        # First, call config-defined setup callbacks
+        AnyFixture.config.before_dump.each { |clbk| clbk.call(**options) }
+        # Then, adapter-defined callbacks
+        adapter.setup_env unless options[:import]
+        # Finally, user-provided callback
+        callback&.call(**options)
+      end
+
+      def run_after_callbacks(callback:, **options)
+        # The order is vice versa to setup
+        callback&.call(**options)
+        adapter.teardown_env unless options[:import]
+        AnyFixture.config.after_dump.each { |clbk| clbk.call(**options) }
+      end
+    end
+  end
+end

data/lib/test_prof/any_fixture/dump/base_adapter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module TestProf
+  module AnyFixture
+    class Dump
+      class BaseAdapter
+        def reset_sequence!(_table_name, _start)
+        end
+
+        def compile_sql(sql, _binds)
+          sql
+        end
+
+        def setup_env
+        end
+
+        def teardown_env
+        end
+
+        def import(_path)
+          false
+        end
+
+        private
+
+        def while_disconnected
+          conn.disconnect!
+          yield
+        ensure
+          conn.reconnect!
+        end
+
+        def conn
+          ActiveRecord::Base.connection
+        end
+
+        def execute(query)
+          conn.execute(query)
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/any_fixture/dump/digest.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module TestProf
+  module AnyFixture
+    class Dump
+      module Digest
+        module_function
+
+        def call(*paths)
+          files = (AnyFixture.config.default_dump_watch_paths + paths).each_with_object([]) do |path_or_glob, acc|
+            if File.file?(path_or_glob)
+              acc << path_or_glob
+            else
+              acc = acc.concat Dir[path_or_glob]
+            end
+            acc
+          end
+
+          return if files.empty?
+
+          file_ids = files.sort.map { |f| "#{File.basename(f)}/#{::Digest::SHA1.file(f).hexdigest}" }
+          ::Digest::SHA1.hexdigest(file_ids.join("/"))
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/any_fixture/dump/postgresql.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "test_prof/any_fixture/dump/base_adapter"
+
+module TestProf
+  module AnyFixture
+    class Dump
+      class PostgreSQL < BaseAdapter
+        UUID_FUNCTIONS = %w[
+          gen_random_uuid
+          uuid_generate_v4
+        ]
+
+        def reset_sequence!(table_name, start)
+          _pk, sequence = conn.pk_and_sequence_for(table_name)
+          return unless sequence
+
+          sequence_name = "#{sequence.schema}.#{sequence.identifier}"
+
+          execute <<~SQL
+            ALTER SEQUENCE #{sequence_name} RESTART WITH #{start}; -- any_fixture:dump
+          SQL
+        end
+
+        def compile_sql(sql, binds)
+          sql.gsub(/\$\d+/) { binds.shift }
+        end
+
+        def import(path)
+          # Test if psql is installed
+          `psql --version`
+
+          tasks = ActiveRecord::Tasks::PostgreSQLDatabaseTasks.new(conn.pool.spec.config.with_indifferent_access)
+
+          while_disconnected do
+            tasks.structure_load(path, "--output=/dev/null")
+          end
+
+          true
+        rescue Errno::ENOENT
+          false
+        end
+
+        def setup_env
+          # Mock UUID generating functions to provide consistent results
+          quoted_functions = UUID_FUNCTIONS.map { |func| "'#{func}'" }.join(", ")
+
+          @uuid_funcs = execute <<~SQL
+            SELECT
+              pp.proname, pn.nspname,
+              pg_get_functiondef(pp.oid) AS definition
+            FROM pg_proc pp
+            JOIN pg_namespace pn
+              ON pn.oid = pp.pronamespace
+            WHERE pp.proname in (#{quoted_functions})
+            ORDER BY pp.oid;
+          SQL
+
+          uuid_funcs.each do |(func, ns, _)|
+            execute <<~SQL
+              CREATE OR REPLACE FUNCTION #{ns}.#{func}()
+                RETURNS UUID
+                LANGUAGE SQL
+                AS $$
+                  SELECT md5(random()::TEXT)::UUID;
+                $$; -- any_fixture:dump
+            SQL
+          end
+
+          execute <<~SQL
+            SELECT setseed(#{rand}); -- any_fixture:dump
+          SQL
+        end
+
+        def teardown_env
+          uuid_funcs.each do |(func, ns, definition)|
+            execute "#{definition}; -- any_fixture:dump"
+          end
+        end
+
+        private
+
+        attr_reader :uuid_funcs
+
+        def execute(query)
+          super.values
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/any_fixture/dump/sqlite.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "test_prof/any_fixture/dump/base_adapter"
+
+module TestProf
+  module AnyFixture
+    class Dump
+      class SQLite < BaseAdapter
+        def reset_sequence!(table_name, start)
+          execute <<~SQL.chomp
+            DELETE FROM sqlite_sequence WHERE name=#{table_name}
+          SQL
+
+          execute <<~SQL.chomp
+            INSERT INTO sqlite_sequence (name, seq)
+            VALUES (#{table_name}, #{start})
+          SQL
+        end
+
+        def compile_sql(sql, binds)
+          sql.gsub(/\?/) { binds.shift }
+        end
+
+        def import(path)
+          db = conn.pool.spec.config[:database]
+          return false if %r{:memory:}.match?(db)
+
+          # Check that sqlite3 is installed
+          `sqlite3 --version`
+
+          while_disconnected do
+            `sqlite3 #{db} < "#{path}"`
+          end
+
+          true
+        rescue Errno::ENOENT
+          false
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/before_all/adapters/active_record.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-if ::ActiveRecord::VERSION::MAJOR < 4
-  require "test_prof/ext/active_record_3"
-  using TestProf::ActiveRecord3Transactions
-end
-
 module TestProf
   module BeforeAll
     module Adapters

data/lib/test_prof/rubocop.rb

@@ -11,4 +11,3 @@ require "rubocop"
 
 require_relative "cops/inject"
 require "test_prof/cops/rspec/aggregate_examples"
-require "test_prof/cops/rspec/aggregate_failures"

data/lib/test_prof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TestProf
-  VERSION = "0.12.2"
+  VERSION = "1.0.0.rc1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-prof
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 1.0.0.rc1
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-03 00:00:00.000000000 Z
+date: 2020-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -119,6 +119,7 @@ files:
 - assets/tagprof.demo.html
 - assets/tagprof.template.html
 - config/default.yml
+- config/rubocop-rspec.yml
 - lib/minitest/base_reporter.rb
 - lib/minitest/event_prof_formatter.rb
 - lib/minitest/test_prof_plugin.rb
@@ -126,6 +127,11 @@ files:
 - lib/test_prof.rb
 - lib/test_prof/any_fixture.rb
 - lib/test_prof/any_fixture/dsl.rb
+- lib/test_prof/any_fixture/dump.rb
+- lib/test_prof/any_fixture/dump/base_adapter.rb
+- lib/test_prof/any_fixture/dump/digest.rb
+- lib/test_prof/any_fixture/dump/postgresql.rb
+- lib/test_prof/any_fixture/dump/sqlite.rb
 - lib/test_prof/before_all.rb
 - lib/test_prof/before_all/adapters/active_record.rb
 - lib/test_prof/before_all/isolator.rb
@@ -136,7 +142,6 @@ files:
 - lib/test_prof/cops/rspec/aggregate_examples/matchers_with_side_effects.rb
 - lib/test_prof/cops/rspec/aggregate_examples/metadata_helpers.rb
 - lib/test_prof/cops/rspec/aggregate_examples/node_matchers.rb
-- lib/test_prof/cops/rspec/aggregate_failures.rb
 - lib/test_prof/cops/rspec/language.rb
 - lib/test_prof/event_prof.rb
 - lib/test_prof/event_prof/custom_events.rb
@@ -148,7 +153,6 @@ files:
 - lib/test_prof/event_prof/monitor.rb
 - lib/test_prof/event_prof/profiler.rb
 - lib/test_prof/event_prof/rspec.rb
-- lib/test_prof/ext/active_record_3.rb
 - lib/test_prof/ext/active_record_refind.rb
 - lib/test_prof/ext/array_bsearch_index.rb
 - lib/test_prof/ext/factory_bot_strategy.rb
@@ -173,8 +177,6 @@ files:
 - lib/test_prof/factory_prof/printers/flamegraph.rb
 - lib/test_prof/factory_prof/printers/simple.rb
 - lib/test_prof/logging.rb
-- lib/test_prof/recipes/active_record_one_love.rb
-- lib/test_prof/recipes/active_record_shared_connection.rb
 - lib/test_prof/recipes/logging.rb
 - lib/test_prof/recipes/minitest/before_all.rb
 - lib/test_prof/recipes/minitest/sample.rb
@@ -228,9 +230,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.6
 signing_key: 

data/lib/test_prof/cops/rspec/aggregate_failures.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      class AggregateExamples
-        def self.registry
-          RuboCop::Cop::Cop.registry
-        end
-      end
-
-      class AggregateFailures < AggregateExamples
-        def initialize(*)
-          super
-          self.class.just_once { warn "`AggregateFailures` cop has been renamed to `AggregateExamples`." }
-        end
-
-        def self.just_once
-          return if @already_done
-          yield
-          @already_done = true
-        end
-      end
-    end
-  end
-end

data/lib/test_prof/ext/active_record_3.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module TestProf
-  # Add missing `begin_transaction` and `rollback_transaction` methods
-  module ActiveRecord3Transactions
-    refine ::ActiveRecord::ConnectionAdapters::AbstractAdapter do
-      def begin_transaction(joinable: true)
-        if open_transactions > 0
-          increment_open_transactions
-          create_savepoint
-        else
-          begin_db_transaction
-        end
-        self.transaction_joinable = joinable
-      end
-
-      def rollback_transaction(*)
-        if open_transactions > 1
-          rollback_to_savepoint
-        else
-          rollback_db_transaction
-        end
-        decrement_open_transactions
-      end
-    end
-  end
-end

data/lib/test_prof/recipes/active_record_one_love.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "./active_record_shared_connection"
-
-# One ❤️
-TestProf::ActiveRecordOneLove = TestProf::ActiveRecordSharedConnection

data/lib/test_prof/recipes/active_record_shared_connection.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module TestProf
-  # Forces ActiveRecord to use the same connection between threads
-  module ActiveRecordSharedConnection # :nodoc: all
-    class << self
-      attr_reader :connection
-
-      def enable!
-        self.connection = ActiveRecord::Base.connection
-      end
-
-      def disable!
-        self.connection = nil
-      end
-
-      def ignore(&block)
-        raise ArgumentError, "Block is required" unless block_given?
-
-        @ignores ||= []
-
-        ignores << block
-      end
-
-      def ignored?(config)
-        !ignores.nil? && ignores.any? { |clbk| clbk.call(config) }
-      end
-
-      private
-
-      attr_reader :ignores
-
-      def connection=(conn)
-        @connection = conn
-        connection.singleton_class.prepend Connection
-        connection
-      end
-    end
-
-    module Connection
-      def shared_lock
-        @shared_lock ||= Mutex.new
-      end
-
-      def exec_cache(*)
-        shared_lock.synchronize { super }
-      end
-
-      def exec_no_cache(*)
-        shared_lock.synchronize { super }
-      end
-
-      def execute(*)
-        shared_lock.synchronize { super }
-      end
-    end
-
-    module Ext
-      def connection
-        return super if ActiveRecordSharedConnection.ignored?(connection_config)
-        ActiveRecordSharedConnection.connection || super
-      end
-    end
-  end
-end
-
-ActiveSupport.on_load(:active_record) do
-  if ::ActiveRecord::Base.connection.pool.respond_to?(:lock_thread=)
-    TestProf.log :warn, "You activated ActiveRecordSharedConnection patch for the Rails version,\n" \
-                        "which has a built-in support for the same functionality.\n" \
-                        "Consider removing it, 'cause this could result in unexpected behaviour.\n\n" \
-                        "Read more in the docs: https://test-prof.evilmartians.io/#/active_record_shared_connection"
-  end
-
-  TestProf::ActiveRecordSharedConnection.enable!
-  ActiveRecord::Base.singleton_class.prepend TestProf::ActiveRecordSharedConnection::Ext
-end