test-prof 0.12.1 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89c1d2f72a772c731bcb32ee68a21129e82a003a40a194f6a503a31e5b445954
-  data.tar.gz: 6ed48924861ec8523a083ba853bf5de43579df0624f95e003ca6d417c9b4e076
+  metadata.gz: 372bc2a293716277d1437df54387b0ce7a091c01a4fc3622f206afac9d299cc9
+  data.tar.gz: 9a21beb5616e03d3b7b8dd2a0d3a2ccd4bd7f5f6004f946ca0d7933ce654289c
 SHA512:
-  metadata.gz: 7c62484546cda02e28ce819790cb3479004a970dc1c88849eb7ff3e55114b71710774f0dbc2ce7d4874036a5513f10585c3c4d805db05a75c93acb69a36436cb
-  data.tar.gz: 4b6d8438fff041a84975c52428f50a03d9f4519a08a2884a35ae45bb43df4c11fa7f375a041477928a1009610dd0dc96d1e702ba6728eb4a2db8a6e147c3119b
+  metadata.gz: 7eccde7e36088e71e7b21fd3637609c4814497e438281cf87cdab75f836ee5a36beea363c7595b1060aeebb91997d2d3764999e62de3d28a8ed75998766de0c8
+  data.tar.gz: 3d4b46a7adde33b1939eb877867bae39f31a8abd5a7db9404ff8ad2631c79ca116dc0cec824da79223e7cf8df3075374b6fe3b939a5f1fc276f3f7319c573407

data/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 ## master (unrealeased)
 
+## 1.0.1 (2021-02-12)
+
+- Fixed AnyFixture deprecation warning.
+
+## 1.0.0 (2021-01-21)
+
+## 1.0.0.rc2 (2021-01-06)
+
+- Make Rails fixtures accesible in `before_all`. ([@palkan][])
+
+You can load and access fixtures when explicitly enabling them via `before_all(setup_fixtures: true, &block)`.
+
+- Minitest's `before_all` is not longer experimental. ([@palkan][])
+
+- Add `after_all` to Minitest in addition to `before_all`. ([@palkan][])
+
+## 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][])
+
 ## 0.12.1 (2020-09-01)
 
 - Minor improvements.

data/README.md

@@ -75,7 +75,7 @@ Add `test-prof` gem to your application:
 
 ```ruby
 group :test do
-  gem "test-prof"
+  gem "test-prof", "~> 1.0"
 end
 ```
 

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,212 @@
+# 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
+        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
+          return unless defined?(:@file)
+
+          file.close
+
+          FileUtils.mv(tmp_path, path)
+        end
+
+        private
+
+        attr_reader :reset_pk, :adapter
+
+        def file
+          @file ||= File.open(tmp_path, "w")
+        end
+
+        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.rb

@@ -32,6 +32,12 @@ module TestProf
         end
       end
 
+      def setup_fixtures(test_object)
+        raise ArgumentError, "Current adapter doesn't support #setup_fixtures" unless adapter.respond_to?(:setup_fixtures)
+
+        adapter.setup_fixtures(test_object)
+      end
+
       def config
         @config ||= Configuration.new
       end
@@ -60,8 +66,11 @@ module TestProf
     class Configuration
       HOOKS = %i[begin rollback].freeze
 
+      attr_accessor :setup_fixtures
+
       def initialize
         @hooks = Hash.new { |h, k| h[k] = HooksChain.new(k) }
+        @setup_fixtures = false
       end
 
       # Add `before` hook for `begin` or

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
@@ -23,6 +18,20 @@ module TestProf
             end
             ::ActiveRecord::Base.connection.rollback_transaction
           end
+
+          def setup_fixtures(test_object)
+            test_object.instance_eval do
+              @@already_loaded_fixtures ||= {}
+              @fixture_cache ||= {}
+
+              if @@already_loaded_fixtures[self.class]
+                @loaded_fixtures = @@already_loaded_fixtures[self.class]
+              else
+                @loaded_fixtures = load_fixtures(config)
+                @@already_loaded_fixtures[self.class] = @loaded_fixtures
+              end
+            end
+          end
         end
       end
     end

data/lib/test_prof/recipes/minitest/before_all.rb

@@ -8,41 +8,59 @@ module TestProf
     # store instance variables
     module Minitest # :nodoc: all
       class Executor
-        attr_reader :active
+        attr_reader :active, :block, :captured_ivars, :teardown_block, :current_test_object,
+          :setup_fixtures
 
         alias active? active
+        alias setup_fixtures? setup_fixtures
 
-        def initialize(&block)
+        def initialize(setup_fixtures: false, &block)
+          @setup_fixtures = setup_fixtures
           @block = block
+          @captured_ivars = []
         end
 
-        def activate!(test_class)
-          return if active?
+        def teardown(&block)
+          @teardown_block = block
+        end
+
+        def activate!(test_object)
+          @current_test_object = test_object
+
+          return restore_ivars(test_object) if active?
           @active = true
-          @examples_left = test_class.runnable_methods.size
+          BeforeAll.setup_fixtures(test_object) if setup_fixtures?
           BeforeAll.begin_transaction do
-            capture!
+            capture!(test_object)
           end
         end
 
-        def try_deactivate!
-          @examples_left -= 1
-          return unless @examples_left.zero?
-
+        def deactivate!
           @active = false
+
+          current_test_object&.instance_eval(&teardown_block) if teardown_block
+
+          @current_test_object = nil
           BeforeAll.rollback_transaction
         end
 
-        def capture!
-          instance_eval(&@block)
+        def capture!(test_object)
+          return unless block
+
+          before_ivars = test_object.instance_variables
+
+          test_object.instance_eval(&block)
+
+          (test_object.instance_variables - before_ivars).each do |ivar|
+            captured_ivars << [ivar, test_object.instance_variable_get(ivar)]
+          end
         end
 
-        def restore_to(test_object)
-          instance_variables.each do |ivar|
-            next if ivar == :@block
+        def restore_ivars(test_object)
+          captured_ivars.each do |(ivar, val)|
             test_object.instance_variable_set(
               ivar,
-              instance_variable_get(ivar)
+              val
             )
           end
         end
@@ -57,22 +75,29 @@ module TestProf
       module ClassMethods
         attr_accessor :before_all_executor
 
-        def before_all(&block)
-          self.before_all_executor = Executor.new(&block)
+        def before_all(setup_fixtures: BeforeAll.config.setup_fixtures, &block)
+          self.before_all_executor = Executor.new(setup_fixtures: setup_fixtures, &block)
 
           prepend(Module.new do
-            def setup
-              self.class.before_all_executor.activate!(self.class)
-              self.class.before_all_executor.restore_to(self)
+            def before_setup
+              self.class.before_all_executor.activate!(self)
               super
             end
+          end)
 
-            def teardown
+          singleton_class.prepend(Module.new do
+            def run(*)
               super
-              self.class.before_all_executor.try_deactivate!
+            ensure
+              before_all_executor&.deactivate!
             end
           end)
         end
+
+        def after_all(&block)
+          self.before_all_executor ||= Executor.new
+          before_all_executor.teardown(&block)
+        end
       end
     end
   end

data/lib/test_prof/recipes/rspec/any_fixture.rb

@@ -15,7 +15,7 @@ RSpec.configure do |config|
   config.include_context "any_fixture:clean", with_clean_fixture: true
 
   config.after(:suite) do
-    TestProf::AnyFixture.report_stats if TestProf::AnyFixture.reporting_enabled?
+    TestProf::AnyFixture.report_stats if TestProf::AnyFixture.config.reporting_enabled?
     TestProf::AnyFixture.reset
   end
 end

data/lib/test_prof/recipes/rspec/before_all.rb

@@ -6,14 +6,22 @@ module TestProf
   module BeforeAll
     # Helper to wrap the whole example group into a transaction
     module RSpec
-      def before_all(&block)
+      def before_all(setup_fixtures: BeforeAll.config.setup_fixtures, &block)
         raise ArgumentError, "Block is required!" unless block_given?
 
-        return before(:all, &block) if within_before_all?
+        if within_before_all?
+          before(:all) do
+            @__inspect_output = "before_all hook"
+            instance_eval(&block)
+          end
+          return
+        end
 
         @__before_all_activated__ = true
 
         before(:all) do
+          @__inspect_output = "before_all hook"
+          BeforeAll.setup_fixtures(self) if setup_fixtures
           BeforeAll.begin_transaction do
             instance_eval(&block)
           end

data/lib/test_prof/recipes/rspec/let_it_be.rb

@@ -108,8 +108,9 @@ module TestProf
 
       LetItBe.module_for(self).module_eval do
         define_method(identifier) do
-          # Trying to detect the context (couldn't find other way so far)
-          if /\(:context\)/.match?(@__inspect_output)
+          # Trying to detect the context
+          # Based on https://github.com/rspec/rspec-rails/commit/7cb796db064f58da7790a92e73ab906ef50b1f34
+          if @__inspect_output.include?("before(:context)") || @__inspect_output.include?("before_all")
             instance_variable_get(:"#{PREFIX}#{identifier}")
           else
             # Fallback to let definition

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.1"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-prof
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 1.0.1
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-01 00:00:00.000000000 Z
+date: 2021-02-12 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

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