test-prof 0.12.0 → 1.0.7

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,21 @@ module TestProf
             end
             ::ActiveRecord::Base.connection.rollback_transaction
           end
+
+          def setup_fixtures(test_object)
+            test_object.instance_eval do
+              @@already_loaded_fixtures ||= {}
+              @fixture_cache ||= {}
+              config = ::ActiveRecord::Base
+
+              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/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
@@ -70,7 +79,7 @@ module TestProf
       #   config.before(:rollback) { ... }
       def before(type, &block)
         validate_hook_type!(type)
-        hooks[type].before << block if block_given?
+        hooks[type].before << block if block
       end
 
       # Add `after` hook for `begin` or
@@ -79,7 +88,7 @@ module TestProf
       #   config.after(:begin) { ... }
       def after(type, &block)
         validate_hook_type!(type)
-        hooks[type].after << block if block_given?
+        hooks[type].after << block if block
       end
 
       def run_hooks(type) # :nodoc:

data/lib/test_prof/cops/rspec/aggregate_examples/its.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module RSpec
-      class AggregateExamples < Cop
+      class AggregateExamples < ::RuboCop::Cop::Cop
         # @example `its`
         #
         #   # Supports regular `its` call with an attribute/method name,

data/lib/test_prof/cops/rspec/aggregate_examples/line_range_helpers.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module RSpec
-      class AggregateExamples < Cop
+      class AggregateExamples < ::RuboCop::Cop::Cop
         # @internal Support methods for keeping newlines around examples.
         module LineRangeHelpers
           include RangeHelp

data/lib/test_prof/cops/rspec/aggregate_examples/matchers_with_side_effects.rb

@@ -5,7 +5,7 @@ require_relative "../language"
 module RuboCop
   module Cop
     module RSpec
-      class AggregateExamples < Cop
+      class AggregateExamples < ::RuboCop::Cop::Cop
         # When aggregated, the expectations will fail when not supposed to or
         # have a risk of not failing when expected to. One example is
         # `validate_presence_of :comment` as it leaves an empty comment after

data/lib/test_prof/cops/rspec/aggregate_examples/metadata_helpers.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module RSpec
-      class AggregateExamples < Cop
+      class AggregateExamples < ::RuboCop::Cop::Cop
         # @internal
         #   Support methods for example metadata.
         #   Examples with similar metadata are grouped.

data/lib/test_prof/cops/rspec/aggregate_examples/node_matchers.rb

@@ -5,7 +5,7 @@ require_relative "../language"
 module RuboCop
   module Cop
     module RSpec
-      class AggregateExamples < Cop
+      class AggregateExamples < ::RuboCop::Cop::Cop
         # @internal
         #   Node matchers and searchers.
         module NodeMatchers

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

@@ -108,7 +108,7 @@ module RuboCop
       #     expect(number).to be_odd
       #   end
       #
-      class AggregateExamples < Cop
+      class AggregateExamples < ::RuboCop::Cop::Cop
         include LineRangeHelpers
         include MetadataHelpers
         include NodeMatchers

data/lib/test_prof/event_prof/custom_events.rb

@@ -6,7 +6,7 @@ module TestProf
     module CustomEvents
       class << self
         def register(event, &block)
-          raise ArgumentError, "Block is required!" unless block_given?
+          raise ArgumentError, "Block is required!" unless block
           registrations[event] = block
         end
 

data/lib/test_prof/event_prof/instrumentations/active_support.rb

@@ -26,7 +26,7 @@ module TestProf::EventProf
 
       class << self
         def subscribe(event, &block)
-          raise ArgumentError, "Block is required!" unless block_given?
+          raise ArgumentError, "Block is required!" unless block
 
           ::ActiveSupport::Notifications.subscribe(event, Subscriber.new(block))
         end

data/lib/test_prof/event_prof/profiler.rb

@@ -6,7 +6,7 @@ module TestProf
       attr_reader :event, :total_count, :total_time, :rank_by, :top_count, :per_example,
         :time, :count, :example_time, :example_count, :absolute_run_time
 
-      alias per_example? per_example
+      alias_method :per_example?, :per_example
 
       def initialize(event:, instrumenter:, rank_by: :time, top_count: 5, per_example: false)
         @event = event
@@ -88,14 +88,13 @@ module TestProf
       end
 
       def results
-        results = {
+        {
           groups: @groups.to_a
         }.tap do |data|
           next unless per_example?
 
           data[:examples] = @examples.to_a
         end
-        results
       end
 
       def take_time(start_ts)
@@ -130,7 +129,7 @@ module TestProf
       end
 
       def each(&block)
-        if block_given?
+        if block
           @profilers.each(&block)
         else
           @profilers.each

data/lib/test_prof/factory_prof/nate_heckler.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "test_prof/factory_prof"
+
+# A standalone Factory Prof printer which is meant to be always enabled
+
+TestProf::FactoryProf.patch!
+
+started_at = TestProf.now
+at_exit do
+  TestProf::FactoryProf::Printers::NateHeckler.dump(
+    TestProf::FactoryProf.result, start_time: started_at
+  )
+end
+
+TestProf::FactoryProf.start

data/lib/test_prof/factory_prof/printers/flamegraph.rb

@@ -11,7 +11,7 @@ module TestProf::FactoryProf
       class << self
         include TestProf::Logging
 
-        def dump(result)
+        def dump(result, **)
           return log(:info, "No factories detected") if result.raw_stats == {}
           report_data = {
             total_stacks: result.stacks.size,

data/lib/test_prof/factory_prof/printers/nate_heckler.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "test_prof/ext/float_duration"
+
+module TestProf::FactoryProf
+  module Printers
+    # See https://twitter.com/nateberkopec/status/1389945187766456333
+    module NateHeckler # :nodoc: all
+      class << self
+        using TestProf::FloatDuration
+        include TestProf::Logging
+
+        def dump(result, start_time:)
+          return if result.raw_stats == {}
+
+          total_time = result.stats.sum { |stat| stat[:top_level_time] }
+          total_run_time = TestProf.now - start_time
+
+          percentage = ((total_time / total_run_time) * 100).round(2)
+
+          log :info, "Time spent in factories: #{total_time.duration} (#{percentage}% of total time)"
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/factory_prof/printers/simple.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
+require "test_prof/ext/float_duration"
+
 module TestProf::FactoryProf
   module Printers
     module Simple # :nodoc: all
       class << self
+        using TestProf::FloatDuration
         include TestProf::Logging
 
-        def dump(result)
+        def dump(result, start_time:)
           return log(:info, "No factories detected") if result.raw_stats == {}
           msgs = []
 
+          total_run_time = TestProf.now - start_time
           total_count = result.stats.sum { |stat| stat[:total_count] }
           total_top_level_count = result.stats.sum { |stat| stat[:top_level_count] }
           total_time = result.stats.sum { |stat| stat[:top_level_time] }
@@ -21,7 +25,7 @@ module TestProf::FactoryProf
 
                Total: #{total_count}
                Total top-level: #{total_top_level_count}
-               Total time: #{format("%.4f", total_time)}s
+               Total time: #{total_time.duration} (out of #{total_run_time.duration})
                Total uniq factories: #{total_uniq_factories}
 
                  total   top-level     total time      time per call      top-level time               name

data/lib/test_prof/factory_prof.rb

@@ -2,6 +2,7 @@
 
 require "test_prof/factory_prof/printers/simple"
 require "test_prof/factory_prof/printers/flamegraph"
+require "test_prof/factory_prof/printers/nate_heckler"
 require "test_prof/factory_prof/factory_builders/factory_bot"
 require "test_prof/factory_prof/factory_builders/fabrication"
 
@@ -10,14 +11,23 @@ module TestProf
   # flamegraphs or detect most popular factories
   module FactoryProf
     FACTORY_BUILDERS = [FactoryBuilders::FactoryBot,
-                        FactoryBuilders::Fabrication].freeze
+      FactoryBuilders::Fabrication].freeze
 
     # FactoryProf configuration
     class Configuration
-      attr_accessor :mode
+      attr_accessor :mode, :printer
 
       def initialize
         @mode = ENV["FPROF"] == "flamegraph" ? :flamegraph : :simple
+        @printer =
+          case ENV["FPROF"]
+          when "flamegraph"
+            Printers::Flamegraph
+          when "nate_heckler"
+            Printers::NateHeckler
+          else
+            Printers::Simple
+          end
       end
 
       # Whether we want to generate flamegraphs
@@ -74,7 +84,15 @@ module TestProf
 
         log :info, "FactoryProf enabled (#{config.mode} mode)"
 
+        patch!
+      end
+
+      def patch!
+        return if @patched
+
         FACTORY_BUILDERS.each(&:patch)
+
+        @patched = true
       end
 
       # Inits FactoryProf and setups at exit hook,
@@ -82,9 +100,11 @@ module TestProf
       def run
         init
 
-        printer = config.flamegraph? ? Printers::Flamegraph : Printers::Simple
+        printer = config.printer
+
+        started_at = TestProf.now
 
-        at_exit { printer.dump(result) }
+        at_exit { printer.dump(result, start_time: started_at) }
 
         start
       end

data/lib/test_prof/logging.rb

@@ -4,23 +4,29 @@ module TestProf
   # Helper for output printing
   module Logging
     COLORS = {
-      info: "\e[34m", # blue
-      warn: "\e[33m", # yellow
-      error: "\e[31m" # red
+      INFO: "\e[34m", # blue
+      WARN: "\e[33m", # yellow
+      ERROR: "\e[31m" # red
     }.freeze
 
-    def log(level, msg)
-      TestProf.config.output.puts(build_log_msg(level, msg))
-    end
+    class Formatter
+      def call(severity, _time, progname, msg)
+        colorize(severity.to_sym, "[#{progname} #{severity}] #{msg}\n")
+      end
 
-    def build_log_msg(level, msg)
-      colorize(level, "[TEST PROF #{level.to_s.upcase}] #{msg}")
-    end
+      private
+
+      def colorize(level, msg)
+        return msg unless TestProf.config.color?
 
-    def colorize(level, msg)
-      return msg unless TestProf.config.color?
+        return msg unless COLORS.key?(level)
 
-      "#{COLORS[level]}#{msg}\e[0m"
+        "#{COLORS[level]}#{msg}\e[0m"
+      end
+    end
+
+    def log(level, msg)
+      TestProf.config.logger.public_send(level, "TEST PROF") { msg }
     end
   end
 end

data/lib/test_prof/recipes/logging.rb

@@ -12,7 +12,7 @@ module TestProf
         def logger
           return @logger if instance_variable_defined?(:@logger)
 
-          @logger = Logger.new(STDOUT)
+          @logger = Logger.new($stdout)
         end
 
         def ar_loggables

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

@@ -2,77 +2,179 @@
 
 require "test_prof/before_all"
 
+Minitest.singleton_class.prepend(Module.new do
+  attr_reader :previous_klass
+  @previous_klass = nil
+
+  def run_one_method(klass, method_name)
+    return super unless klass.respond_to?(:parallelized) && klass.parallelized
+
+    if @previous_klass && @previous_klass != klass
+      @previous_klass.before_all_executor&.deactivate!
+    end
+    @previous_klass = klass
+
+    super
+  end
+end)
+
 module TestProf
   module BeforeAll
     # Add before_all hook to Minitest: wrap all examples into a transaction and
     # 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, :parent
 
-        alias active? active
+        alias_method :active?, :active
+        alias_method :setup_fixtures?, :setup_fixtures
 
-        def initialize(&block)
+        def initialize(setup_fixtures: false, parent: nil, &block)
+          @parent = parent
+          # Fixtures must be instantiated if any of the executors needs them
+          @setup_fixtures = setup_fixtures || parent&.setup_fixtures
           @block = block
+          @captured_ivars = []
+        end
+
+        def teardown(&block)
+          @teardown_block = block
         end
 
-        def activate!(test_class)
-          return if active?
+        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!
+          return unless active
 
           @active = false
+
+          perform_teardown(current_test_object)
+
+          @current_test_object = nil
           BeforeAll.rollback_transaction
         end
 
-        def capture!
-          instance_eval(&@block)
+        def capture!(test_object)
+          before_ivars = test_object.instance_variables
+
+          perform_setup(test_object)
+
+          (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
+
+        def perform_setup(test_object)
+          parent&.perform_setup(test_object)
+          test_object.instance_eval(&block) if block
+        end
+
+        def perform_teardown(test_object)
+          current_test_object&.instance_eval(&teardown_block) if teardown_block
+          parent&.perform_teardown(test_object)
+        end
       end
 
       class << self
         def included(base)
           base.extend ClassMethods
+
+          base.cattr_accessor :parallelized
+          if base.respond_to?(:parallelize_teardown)
+            base.parallelize_teardown do
+              last_klass = ::Minitest.previous_klass
+              if last_klass&.respond_to?(:parallelized) && last_klass&.parallelized
+                last_klass.before_all_executor&.deactivate!
+              end
+            end
+          end
+
+          if base.respond_to?(:parallelize)
+            base.singleton_class.prepend(Module.new do
+              def parallelize(workers: :number_of_processors, with: :processes)
+                # super.parallelize returns nil when no parallelization is set up
+                if super(workers: workers, with: with).nil?
+                  return
+                end
+
+                case with
+                when :processes
+                  self.parallelized = true
+                when :threads
+                  warn "!!! before_all is not implemented for parallalization with threads and " \
+                    "could work incorrectly"
+                else
+                  warn "!!! tests are using an unknown parallelization strategy and before_all " \
+                    "could work incorrectly"
+                end
+              end
+            end)
+          end
         end
       end
 
       module ClassMethods
-        attr_accessor :before_all_executor
+        attr_writer :before_all_executor
 
-        def before_all(&block)
-          self.before_all_executor = Executor.new(&block)
+        def before_all_executor
+          return @before_all_executor if instance_variable_defined?(:@before_all_executor)
+
+          @before_all_executor = if superclass.respond_to?(:before_all_executor)
+            superclass.before_all_executor
+          end
+        end
+
+        def before_all(setup_fixtures: BeforeAll.config.setup_fixtures, &block)
+          self.before_all_executor = Executor.new(
+            setup_fixtures: setup_fixtures,
+            parent: before_all_executor,
+            &block
+          )
+
+          # Do not add patches multiple times
+          return if before_all_executor.parent
 
           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! unless parallelized
             end
           end)
         end
+
+        def after_all(&block)
+          self.before_all_executor = Executor.new(parent: before_all_executor)
+          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)
-        raise ArgumentError, "Block is required!" unless block_given?
+      def before_all(setup_fixtures: BeforeAll.config.setup_fixtures, &block)
+        raise ArgumentError, "Block is required!" unless block
 
-        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

@@ -55,9 +55,7 @@ module TestProf
       end
 
       def module_for(group)
-        modules[group] ||= begin
-          Module.new.tap { |mod| group.prepend(mod) }
-        end
+        modules[group] ||= Module.new.tap { |mod| group.prepend(mod) }
       end
 
       private
@@ -91,8 +89,7 @@ module TestProf
       initializer = proc do
         instance_variable_set(:"#{TestProf::LetItBe::PREFIX}#{identifier}", instance_exec(&block))
       rescue FrozenError => e
-        e.message << TestProf::LetItBe::FROZEN_ERROR_HINT
-        raise
+        raise e.exception("#{e.message}#{TestProf::LetItBe::FROZEN_ERROR_HINT}")
       end
 
       default_options = LetItBe.config.default_modifiers.dup
@@ -108,8 +105,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 /(before|after)\(:context\)/.match?(@__inspect_output) || @__inspect_output.include?("before_all")
             instance_variable_get(:"#{PREFIX}#{identifier}")
           else
             # Fallback to let definition
@@ -242,7 +240,7 @@ end
 RSpec.configure do |config|
   config.after(:example) do |example|
     if example.exception&.is_a?(FrozenError)
-      example.exception.message << TestProf::LetItBe::FROZEN_ERROR_HINT
+      example.exception.message << TestProf::LetItBe::FROZEN_ERROR_HINT unless example.exception.message.frozen?
     end
   end
 end