test-prof 0.7.5 → 0.9.0

data/lib/test_prof/factory_doctor.rb

@@ -3,6 +3,7 @@
 require "test_prof"
 require "test_prof/factory_bot"
 require "test_prof/factory_doctor/factory_bot_patch"
+require "test_prof/factory_doctor/fabrication_patch"
 
 module TestProf
   # FactoryDoctor is a tool that helps you identify
@@ -18,7 +19,7 @@ module TestProf
       end
 
       def bad?
-        count > 0 && queries_count.zero?
+        count > 0 && queries_count.zero? && time >= FactoryDoctor.config.threshold
       end
     end
 
@@ -38,26 +39,47 @@ module TestProf
       \ASAVEPOINT
     )}xi.freeze
 
+    class Configuration
+      attr_accessor :event, :threshold
+
+      def initialize
+        # event to track for DB interactions
+        @event = ENV.fetch("FDOC_EVENT", "sql.active_record")
+        # consider result good if time wasted less then threshold
+        @threshold = ENV.fetch("FDOC_THRESHOLD", "0.01").to_f
+      end
+    end
+
     class << self
       include TestProf::Logging
 
-      attr_reader :event
       attr_reader :count, :time, :queries_count
 
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
       # Patch factory lib, init counters
-      def init(event = 'sql.active_record')
-        @event = event
+      def init
         reset!
 
-        log :info, "FactoryDoctor enabled"
+        log :info, "FactoryDoctor enabled (event: \"#{config.event}\", threshold: #{config.threshold})"
 
         # Monkey-patch FactoryBot / FactoryGirl
         TestProf::FactoryBot::FactoryRunner.prepend(FactoryBotPatch) if
           defined?(TestProf::FactoryBot)
 
+        # Monkey-patch Fabrication
+        ::Fabricate.singleton_class.prepend(FabricationPatch) if
+          defined?(::Fabricate)
+
         subscribe!
 
-        @stamp = ENV['FDOC_STAMP']
+        @stamp = ENV["FDOC_STAMP"]
 
         RSpecStamp.config.tags = @stamp if stamp?
       end
@@ -122,7 +144,7 @@ module TestProf
       end
 
       def subscribe!
-        ::ActiveSupport::Notifications.subscribe(event) do |_name, _start, _finish, _id, query|
+        ::ActiveSupport::Notifications.subscribe(config.event) do |_name, _start, _finish, _id, query|
           next if ignore? || !running? || within_factory?
           next if query[:sql] =~ IGNORED_QUERIES_PATTERN
           @queries_count += 1

data/lib/test_prof/factory_prof/factory_builders/fabrication.rb

@@ -10,7 +10,7 @@ module TestProf
       class Fabrication
         # Monkey-patch Fabrication
         def self.patch
-          TestProf.require 'fabrication' do
+          TestProf.require "fabrication" do
             ::Fabricate.singleton_class.prepend(FabricationPatch)
           end
         end

data/lib/test_prof/factory_prof/factory_builders/factory_bot.rb

@@ -2,6 +2,7 @@
 
 require "test_prof/factory_prof/factory_bot_patch"
 require "test_prof/factory_bot"
+require "test_prof/ext/factory_bot_strategy"
 
 module TestProf
   module FactoryProf
@@ -9,23 +10,7 @@ module TestProf
       # implementation of #patch and #track methods
       # to provide unified interface for all factory-building gems
       class FactoryBot
-        # FactoryBot 5.0 uses strategy classes for associations,
-        # older versions and top-level invocations use Symbols
-        using(Module.new do
-          refine Symbol do
-            def create?
-              self == :create
-            end
-          end
-
-          if defined?(::FactoryBot::Strategy::Create)
-            refine Class do
-              def create?
-                self <= ::FactoryBot::Strategy::Create
-              end
-            end
-          end
-        end)
+        using TestProf::FactoryBotStrategy
 
         # Monkey-patch FactoryBot / FactoryGirl
         def self.patch

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

@@ -15,7 +15,7 @@ module TestProf::FactoryProf
           return log(:info, "No factories detected") if result.raw_stats == {}
           report_data = {
             total_stacks: result.stacks.size,
-            total: result.total
+            total: result.total_count
           }
 
           report_data[:roots] = convert_stacks(result)
@@ -45,7 +45,11 @@ module TestProf::FactoryProf
                 node = paths[path]
                 node[:value] += 1
               else
-                node = { name: sample, value: 1, total: result.raw_stats.fetch(sample)[:total] }
+                node = {
+                  name: sample,
+                  value: 1,
+                  total: result.raw_stats.fetch(sample)[:total_count]
+                }
                 paths[path] = node
 
                 if parent.nil?

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

@@ -10,23 +10,25 @@ module TestProf::FactoryProf
           return log(:info, "No factories detected") if result.raw_stats == {}
           msgs = []
 
-          total = result.stats.sum { |stat| stat[:total] }
-          total_top_level = result.stats.sum { |stat| stat[:top_level] }
+          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] }
           total_uniq_factories = result.stats.map { |stat| stat[:name] }.uniq.count
 
           msgs <<
             <<~MSG
               Factories usage
 
-               Total: #{total}
-               Total top-level: #{total_top_level}
+               Total: #{total_count}
+               Total top-level: #{total_top_level_count}
+               Total time: #{format("%.4f", total_time)}s
                Total uniq factories: #{total_uniq_factories}
 
-               total      top-level                            name
+                 total   top-level   total time   top-level time                           name
             MSG
 
           result.stats.each do |stat|
-            msgs << format("%6d    %11d  %30s", stat[:total], stat[:top_level], stat[:name])
+            msgs << format("%8d %11d %11.4fs %15.4fs %30s", stat[:total_count], stat[:top_level_count], stat[:total_time], stat[:top_level_time], stat[:name])
           end
 
           log :info, msgs.join("\n")

data/lib/test_prof/factory_prof.rb

@@ -17,7 +17,7 @@ module TestProf
       attr_accessor :mode
 
       def initialize
-        @mode = ENV['FPROF'] == 'flamegraph' ? :flamegraph : :simple
+        @mode = ENV["FPROF"] == "flamegraph" ? :flamegraph : :simple
       end
 
       # Whether we want to generate flamegraphs
@@ -36,23 +36,24 @@ module TestProf
 
       # Returns sorted stats
       def stats
-        return @stats if instance_variable_defined?(:@stats)
+        @stats ||= @raw_stats.values
+          .sort_by { |el| -el[:total_count] }
+      end
 
-        @stats = @raw_stats.values
-                           .sort_by { |el| -el[:total] }
+      def total_count
+        @total_count ||= @raw_stats.values.sum { |v| v[:total_count] }
       end
 
-      def total
-        return @total if instance_variable_defined?(:@total)
-        @total = @raw_stats.values.sum { |v| v[:total] }
+      def total_time
+        @total_time ||= @raw_stats.values.sum { |v| v[:total_time] }
       end
 
       private
 
       def sorted_stats(key)
         @raw_stats.values
-                  .map { |el| [el[:name], el[key]] }
-                  .sort_by { |el| -el[1] }
+          .map { |el| [el[:name], el[key]] }
+          .sort_by { |el| -el[1] }
       end
     end
 
@@ -103,13 +104,18 @@ module TestProf
 
       def track(factory)
         return yield unless running?
+        @depth += 1
+        @current_stack << factory if config.flamegraph?
+        @stats[factory][:total_count] += 1
+        @stats[factory][:top_level_count] += 1 if @depth == 1
+        t1 = TestProf.now
         begin
-          @depth += 1
-          @current_stack << factory if config.flamegraph?
-          @stats[factory][:total] += 1
-          @stats[factory][:top_level] += 1 if @depth == 1
           yield
         ensure
+          t2 = TestProf.now
+          elapsed = t2 - t1
+          @stats[factory][:total_time] += elapsed
+          @stats[factory][:top_level_time] += elapsed if @depth == 1
           @depth -= 1
           flush_stack if @depth.zero?
         end
@@ -120,7 +126,15 @@ module TestProf
       def reset!
         @stacks = [] if config.flamegraph?
         @depth = 0
-        @stats = Hash.new { |h, k| h[k] = { name: k, total: 0, top_level: 0 } }
+        @stats = Hash.new do |h, k|
+          h[k] = {
+            name: k,
+            total_count: 0,
+            top_level_count: 0,
+            total_time: 0.0,
+            top_level_time: 0.0
+          }
+        end
         flush_stack
       end
 
@@ -137,6 +151,6 @@ module TestProf
   end
 end
 
-TestProf.activate('FPROF') do
+TestProf.activate("FPROF") do
   TestProf::FactoryProf.run
 end

data/lib/test_prof/recipes/logging.rb

@@ -2,44 +2,109 @@
 
 require "test_prof"
 
+module TestProf
+  module Rails
+    # Add `with_logging` and `with_ar_logging helpers`
+    module LoggingHelpers
+      class << self
+        attr_writer :logger
+
+        def logger
+          return @logger if instance_variable_defined?(:@logger)
+
+          @logger = Logger.new(STDOUT)
+        end
+
+        def ar_loggables
+          return @ar_loggables if instance_variable_defined?(:@ar_loggables)
+
+          @ar_loggables = [
+            ::ActiveRecord::Base,
+            ::ActiveSupport::LogSubscriber
+          ]
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def all_loggables
+          return @all_loggables if instance_variable_defined?(:@all_loggables)
+
+          @all_loggables = [
+            ::ActiveSupport::LogSubscriber,
+            ::Rails,
+            defined?(::ActiveRecord::Base) && ::ActiveRecord::Base,
+            defined?(::ActiveJob::Base) && ::ActiveJob::Base,
+            defined?(::ActionView::Base) && ::ActionView::Base,
+            defined?(::ActionMailer::Base) && ::ActionMailer::Base,
+            defined?(::ActionCable::Server::Base.config) && ::ActionCable::Server::Base.config,
+            defined?(::ActiveStorage) && ::ActiveStorage
+          ].compact
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        def swap_logger(loggables)
+          loggables.map do |loggable|
+            was_logger = loggable.logger
+            loggable.logger = logger
+            was_logger
+          end
+        end
+
+        def restore_logger(was_loggers, loggables)
+          loggables.each_with_index do |loggable, i|
+            loggable.logger = was_loggers[i]
+          end
+        end
+      end
+
+      # Enable verbose Rails logging within a block
+      def with_logging
+        *loggers = LoggingHelpers.swap_logger(LoggingHelpers.all_loggables)
+        yield
+      ensure
+        LoggingHelpers.restore_logger(loggers, LoggingHelpers.all_loggables)
+      end
+
+      def with_ar_logging
+        *loggers = LoggingHelpers.swap_logger(LoggingHelpers.ar_loggables)
+        yield
+      ensure
+        LoggingHelpers.restore_logger(loggers, LoggingHelpers.ar_loggables)
+      end
+    end
+  end
+end
+
 if TestProf.rspec?
-  RSpec.shared_context "logging:verbose", log: true do
+  RSpec.shared_context "logging:verbose" do
     around(:each) do |ex|
-      *loggers = ActiveSupport::LogSubscriber.logger,
-                 Rails.logger,
-                 ActiveRecord::Base.logger
-      ActiveSupport::LogSubscriber.logger =
-        Rails.logger =
-          ActiveRecord::Base.logger = Logger.new(STDOUT)
-      ex.run
-      ActiveSupport::LogSubscriber.logger,
-      Rails.logger,
-      ActiveRecord::Base.logger = *loggers
+      with_logging(&ex)
     end
   end
 
-  RSpec.shared_context "logging:active_record", log: :ar do
+  RSpec.shared_context "logging:active_record" do
     around(:each) do |ex|
-      *loggers = ActiveRecord::Base.logger,
-                 ActiveSupport::LogSubscriber.logger
-      ActiveSupport::LogSubscriber.logger =
-        ActiveRecord::Base.logger = Logger.new(STDOUT)
-      ex.run
-      ActiveSupport::LogSubscriber.logger,
-      ActiveRecord::Base.logger = *loggers
+      with_ar_logging(&ex)
     end
   end
+
+  RSpec.configure do |config|
+    config.include TestProf::Rails::LoggingHelpers
+    config.include_context "logging:active_record", log: :ar
+    config.include_context "logging:verbose", log: true
+  end
 end
 
 TestProf.activate("LOG", "all") do
   TestProf.log :info, "Rails verbose logging enabled"
   ActiveSupport::LogSubscriber.logger =
     Rails.logger =
-      ActiveRecord::Base.logger = Logger.new(STDOUT)
+      ActiveRecord::Base.logger = TestProf::Rails::LoggingHelpers.logger
 end
 
 TestProf.activate("LOG", "ar") do
   TestProf.log :info, "Active Record verbose logging enabled"
   ActiveSupport::LogSubscriber.logger =
-    ActiveRecord::Base.logger = Logger.new(STDOUT)
+    ActiveRecord::Base.logger = TestProf::Rails::LoggingHelpers.logger
 end

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

@@ -20,8 +20,9 @@ module TestProf
           return if active?
           @active = true
           @examples_left = test_class.runnable_methods.size
-          BeforeAll.begin_transaction
-          capture!
+          BeforeAll.begin_transaction do
+            capture!
+          end
         end
 
         def try_deactivate!

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

@@ -14,7 +14,7 @@ module TestProf
       def suites
         # Make sure that sample contains only _real_ suites
         Minitest::Runnable.runnables
-                          .reject { |suite| CORE_RUNNABLES.include?(suite) }
+          .reject { |suite| CORE_RUNNABLES.include?(suite) }
       end
 
       def sample_groups(sample_size)
@@ -39,10 +39,10 @@ module TestProf
 
     # Overrides Minitest.run
     def run(*)
-      if ENV['SAMPLE']
-        MinitestSample.sample_examples(ENV['SAMPLE'].to_i)
-      elsif ENV['SAMPLE_GROUPS']
-        MinitestSample.sample_groups(ENV['SAMPLE_GROUPS'].to_i)
+      if ENV["SAMPLE"]
+        MinitestSample.sample_examples(ENV["SAMPLE"].to_i)
+      elsif ENV["SAMPLE_GROUPS"]
+        MinitestSample.sample_groups(ENV["SAMPLE_GROUPS"].to_i)
       end
       super
     end

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

@@ -3,7 +3,7 @@
 require "test_prof/any_fixture"
 require "test_prof/recipes/rspec/before_all"
 
-RSpec.shared_context "any_fixture:clean", with_clean_fixture: true do
+RSpec.shared_context "any_fixture:clean" do
   extend TestProf::BeforeAll::RSpec
 
   before_all do
@@ -12,6 +12,8 @@ RSpec.shared_context "any_fixture:clean", with_clean_fixture: true do
 end
 
 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.reset

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

@@ -9,13 +9,14 @@ module TestProf
       def before_all(&block)
         raise ArgumentError, "Block is required!" unless block_given?
 
-        return before(:all, &block) if within_before_all?
+        return within_before_all(&block) if within_before_all?
 
         @__before_all_activated__ = true
 
         before(:all) do
-          BeforeAll.begin_transaction
-          instance_eval(&block)
+          BeforeAll.begin_transaction do
+            instance_eval(&block)
+          end
         end
 
         after(:all) do
@@ -23,6 +24,14 @@ module TestProf
         end
       end
 
+      def within_before_all(&block)
+        before(:all) do
+          BeforeAll.within_transaction do
+            instance_eval(&block)
+          end
+        end
+      end
+
       def within_before_all?
         instance_variable_defined?(:@__before_all_activated__)
       end

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

@@ -4,7 +4,11 @@ require "test_prof/factory_all_stub"
 
 TestProf::FactoryAllStub.init
 
-RSpec.shared_context "factory:stub", factory: :stub do
+RSpec.shared_context "factory:stub" do
   prepend_before(:all) { TestProf::FactoryAllStub.enable! }
   append_after(:all) { TestProf::FactoryAllStub.disable! }
 end
+
+RSpec.configure do |config|
+  config.include_context "factory:stub", factory: :stub
+end

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

@@ -7,18 +7,32 @@ module TestProf
   # Just like `let`, but persist the result for the whole group.
   # NOTE: Experimental and magical, for more control use `before_all`.
   module LetItBe
+    class Configuration
+      # Define an alias for `let_it_be` with the predefined options:
+      #
+      #   TestProf::LetItBe.configure do |config|
+      #     config.alias_to :let_it_be_reloaded, reload: true
+      #   end
+      def alias_to(name, **default_args)
+        LetItBe.define_let_it_be_alias(name, **default_args)
+      end
+    end
+
     class << self
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
       def module_for(group)
         modules[group] ||= begin
           Module.new.tap { |mod| group.prepend(mod) }
         end
       end
 
-      # Only works with RSpec 3.2.0
-      def supported?
-        TestProf::Utils.verify_gem_version('rspec-core', at_least: '3.2.0')
-      end
-
       private
 
       def modules
@@ -28,20 +42,21 @@ module TestProf
     # Use uniq prefix for instance variables to avoid collisions
     # We want to use the power of Ruby's unicode support)
     # And we love cats!)
-    PREFIX = RUBY_ENGINE == 'jruby' ? "@__jruby_is_not_cat_friendly__" : "@😸"
+    PREFIX = RUBY_ENGINE == "jruby" ? "@__jruby_is_not_cat_friendly__" : "@😸"
 
-    def let_it_be(identifier, **options, &block)
-      unless LetItBe.supported?
-        TestProf.log :warn, "let_it_be requires RSpec >= 3.2.0. Fallback to let!"
-        return let!(identifier, &block)
+    def self.define_let_it_be_alias(name, **default_args)
+      define_method(name) do |identifier, **options, &blk|
+        let_it_be(identifier, default_args.merge(options), &blk)
       end
+    end
 
+    def let_it_be(identifier, **options, &block)
       initializer = proc do
         instance_variable_set(:"#{PREFIX}#{identifier}", instance_exec(&block))
       end
 
       if within_before_all?
-        before(:all, &initializer)
+        within_before_all(&initializer)
       else
         before_all(&initializer)
       end
@@ -72,7 +87,7 @@ 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 @__inspect_output =~ /\(:context\)/
+          if /\(:context\)/.match?(@__inspect_output)
             instance_variable_get(:"#{PREFIX}#{identifier}")
           else
             # Fallback to let definition

data/lib/test_prof/rspec_dissect/rspec.rb

@@ -10,8 +10,7 @@ module TestProf
 
       NOTIFICATIONS = %i[
         example_group_finished
-        example_passed
-        example_failed
+        example_finished
       ].freeze
 
       def initialize
@@ -35,9 +34,6 @@ module TestProf
         @examples_time += notification.example.execution_result.run_time
       end
 
-      alias example_passed example_finished
-      alias example_failed example_finished
-
       def example_group_finished(notification)
         return unless notification.group.top_level?
 
@@ -127,7 +123,7 @@ module TestProf
 end
 
 # Register RSpecDissect listener
-TestProf.activate('RD_PROF') do
+TestProf.activate("RD_PROF") do
   RSpec.configure do |config|
     listener = nil
 

data/lib/test_prof/rspec_dissect.rb

@@ -21,10 +21,10 @@ module TestProf
         Thread.current[:_rspec_dissect_let_depth] += 1
         begin
           res = if Thread.current[:_rspec_dissect_let_depth] == 1
-                  RSpecDissect.track(:let, id) { super }
-                else
-                  super
-                end
+            RSpecDissect.track(:let, id) { super }
+          else
+            super
+          end
         ensure
           Thread.current[:_rspec_dissect_let_depth] -= 1
         end
@@ -45,14 +45,14 @@ module TestProf
 
       def initialize
         @let_stats_enabled = true
-        @let_top_count = (ENV['RD_PROF_LET_TOP'] || 3).to_i
-        @top_count = (ENV['RD_PROF_TOP'] || 5).to_i
-        @stamp = ENV['RD_PROF_STAMP']
-        @mode = ENV['RD_PROF'] == '1' ? 'all' : ENV['RD_PROF']
+        @let_top_count = (ENV["RD_PROF_LET_TOP"] || 3).to_i
+        @top_count = (ENV["RD_PROF_TOP"] || 5).to_i
+        @stamp = ENV["RD_PROF_STAMP"]
+        @mode = ENV["RD_PROF"] == "1" ? "all" : ENV["RD_PROF"]
 
         unless MODES.include?(mode)
           raise "Unknown RSpecDissect mode: #{mode};" \
-                "available modes: #{MODES.join(', ')}"
+                "available modes: #{MODES.join(", ")}"
         end
 
         RSpecStamp.config.tags = @stamp if stamp?
@@ -87,10 +87,8 @@ module TestProf
       def init
         RSpec::Core::Example.prepend(ExampleInstrumentation)
 
-        if memoization_available?
-          RSpec::Core::MemoizedHelpers::ThreadsafeMemoized.prepend(MemoizedInstrumentation)
-          RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized.prepend(MemoizedInstrumentation)
-        end
+        RSpec::Core::MemoizedHelpers::ThreadsafeMemoized.prepend(MemoizedInstrumentation)
+        RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized.prepend(MemoizedInstrumentation)
 
         @data = {}
 
@@ -100,10 +98,6 @@ module TestProf
 
         reset!
 
-        if config.let? && !memoization_available?
-          log :warn, "RSpecDissect: `let` profiling is not supported (requires RSpec >= 3.3.0)\n"
-        end
-
         log :info, "RSpecDissect enabled"
       end
 
@@ -120,7 +114,7 @@ module TestProf
 
       def reset!
         METRICS.each do |type|
-          @data[type.to_s] = { time: 0.0, meta: [] }
+          @data[type.to_s] = {time: 0.0, meta: []}
         end
       end
 
@@ -148,6 +142,6 @@ require "test_prof/rspec_dissect/collectors/let"
 require "test_prof/rspec_dissect/collectors/before"
 require "test_prof/rspec_dissect/rspec" if TestProf.rspec?
 
-TestProf.activate('RD_PROF') do
+TestProf.activate("RD_PROF") do
   TestProf::RSpecDissect.init
 end