test-prof 0.4.9 → 0.5.0

data/lib/minitest/event_prof_formatter.rb

@@ -11,35 +11,37 @@ module Minitest
       using ::TestProf::StringTruncate
       using ::TestProf::StringStripHeredoc
 
-      def initialize(profiler)
-        @profiler = profiler
+      def initialize(profilers)
+        @profilers = profilers
         @results = []
       end
 
       def prepare_results
-        total_results
-        by_groups
-        by_examples
+        @profilers.each do |profiler|
+          total_results(profiler)
+          by_groups(profiler)
+          by_examples(profiler)
+        end
         @results.join
       end
 
       private
 
-      def total_results
+      def total_results(profiler)
         @results <<
           <<-MSG.strip_heredoc
-            EventProf results for #{@profiler.event}
+            EventProf results for #{profiler.event}
 
-            Total time: #{@profiler.total_time.duration}
-            Total events: #{@profiler.total_count}
+            Total time: #{profiler.total_time.duration}
+            Total events: #{profiler.total_count}
 
-            Top #{@profiler.top_count} slowest suites (by #{@profiler.rank_by}):
+            Top #{profiler.top_count} slowest suites (by #{profiler.rank_by}):
 
           MSG
       end
 
-      def by_groups
-        @profiler.results[:groups].each do |group|
+      def by_groups(profiler)
+        profiler.results[:groups].each do |group|
           description = group[:id][:name]
           location = group[:id][:location]
 
@@ -50,11 +52,11 @@ module Minitest
         end
       end
 
-      def by_examples
-        return unless @profiler.results[:examples]
-        @results << "\nTop #{@profiler.top_count} slowest tests (by #{@profiler.rank_by}):\n\n"
+      def by_examples(profiler)
+        return unless profiler.results[:examples]
+        @results << "\nTop #{profiler.top_count} slowest tests (by #{profiler.rank_by}):\n\n"
 
-        @profiler.results[:examples].each do |example|
+        profiler.results[:examples].each do |example|
           description = example[:id][:name]
           location = example[:id][:location]
 

data/lib/test_prof/any_fixture/dsl.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module TestProf
+  module AnyFixture
+    # Adds "global" `fixture` method (through refinement)
+    module DSL
+      module Ext # :nodoc:
+        def fixture(id, &block)
+          ::TestProf::AnyFixture.register(:"#{id}", &block)
+        end
+      end
+
+      refine Kernel do
+        include Ext
+      end
+    end
+  end
+end

data/lib/test_prof/any_fixture.rb

@@ -1,27 +1,53 @@
 # frozen_string_literal: true
 
+require "test_prof/ext/float_duration"
+require "test_prof/ext/string_strip_heredoc"
+
 module TestProf
   # Make DB fixtures from blocks.
   module AnyFixture
     INSERT_RXP = /^INSERT INTO ([\S]+)/
 
-    class Cache # :nodoc:
-      attr_reader :store
+    using FloatDuration
+    using StringStripHeredoc
 
-      delegate :clear, to: :store
+    class Cache # :nodoc:
+      attr_reader :store, :stats
 
       def initialize
         @store = {}
+        @stats = {}
       end
 
       def fetch(key)
-        return store[key] if store.key?(key)
+        if store.key?(key)
+          stats[key][:hit] += 1
+          return store[key]
+        end
+
         return unless block_given?
+
+        ts = TestProf.now
         store[key] = yield
+        stats[key] = { time: TestProf.now - ts, hit: 0 }
+        store[key]
+      end
+
+      def clear
+        store.clear
+        stats.clear
       end
     end
 
     class << self
+      include Logging
+
+      attr_accessor :reporting_enabled
+
+      def reporting_enabled?
+        reporting_enabled == true
+      end
+
       # Register a block of code as a fixture,
       # returns the result of the block execution
       def register(id)
@@ -34,10 +60,12 @@ module TestProf
 
       # Clean all affected tables (but do not reset cache)
       def clean
-        tables_cache.keys.reverse_each do |table|
-          ActiveRecord::Base.connection.execute %(
-            DELETE FROM #{table}
-          )
+        disable_referential_integrity do
+          tables_cache.keys.reverse_each do |table|
+            ActiveRecord::Base.connection.execute %(
+              DELETE FROM #{table}
+            )
+          end
         end
       end
 
@@ -53,6 +81,54 @@ module TestProf
         tables_cache[matches[1]] = true if matches
       end
 
+      def report_stats
+        msgs = []
+
+        msgs <<
+          <<-MSG.strip_heredoc
+            AnyFixture usage stats:
+          MSG
+
+        first_column = cache.stats.keys.map(&:size).max + 2
+
+        msgs << format(
+          "%#{first_column}s  %12s  %9s  %12s",
+          'key', 'build time', 'hit count', 'saved time'
+        )
+
+        msgs << ""
+
+        total_spent = 0.0
+        total_saved = 0.0
+        total_miss = 0.0
+
+        cache.stats.to_a.sort_by { |(_, v)| -v[:hit] }.each do |(key, stats)|
+          total_spent += stats[:time]
+
+          saved = stats[:time] * stats[:hit]
+
+          total_saved += saved
+
+          total_miss += stats[:time] if stats[:hit].zero?
+
+          msgs << format(
+            "%#{first_column}s  %12s  %9d  %12s",
+            key, stats[:time].duration, stats[:hit],
+            saved.duration
+          )
+        end
+
+        msgs <<
+          <<-MSG.strip_heredoc
+
+            Total time spent: #{total_spent.duration}
+            Total time saved: #{total_saved.duration}
+            Total time wasted: #{total_miss.duration}
+          MSG
+
+        log :info, msgs.join("\n")
+      end
+
       private
 
       def cache
@@ -62,6 +138,14 @@ module TestProf
       def tables_cache
         @tables_cache ||= {}
       end
+
+      def disable_referential_integrity
+        connection = ActiveRecord::Base.connection
+        return yield unless connection.respond_to?(:disable_referential_integrity)
+        connection.disable_referential_integrity { yield }
+      end
     end
+
+    self.reporting_enabled = ENV['ANYFIXTURE_REPORT'] == '1'
   end
 end

data/lib/test_prof/event_prof/custom_events/factory_create.rb

@@ -44,7 +44,7 @@ module TestProf::EventProf::CustomEvents
   end
 end
 
-TestProf.activate('EVENT_PROF', 'factory.create') do
+TestProf::EventProf::CustomEvents.register("factory.create") do
   if defined? TestProf::FactoryBot
     TestProf::EventProf::CustomEvents::FactoryCreate.setup!
   else

data/lib/test_prof/event_prof/custom_events/sidekiq_inline.rb

@@ -40,7 +40,7 @@ module TestProf::EventProf::CustomEvents
   end
 end
 
-TestProf.activate('EVENT_PROF', 'sidekiq.inline') do
+TestProf::EventProf::CustomEvents.register("sidekiq.inline") do
   if TestProf.require(
     'sidekiq/testing',
     <<-MSG.strip_heredoc

data/lib/test_prof/event_prof/custom_events/sidekiq_jobs.rb

@@ -27,7 +27,7 @@ module TestProf::EventProf::CustomEvents
   end
 end
 
-TestProf.activate('EVENT_PROF', 'sidekiq.jobs') do
+TestProf::EventProf::CustomEvents.register("sidekiq.jobs") do
   if TestProf.require(
     'sidekiq/testing',
     <<-MSG.strip_heredoc

data/lib/test_prof/event_prof/custom_events.rb

@@ -1,5 +1,35 @@
 # frozen_string_literal: true
 
+module TestProf
+  module EventProf
+    # Registers and activates custom events (which require patches).
+    module CustomEvents
+      class << self
+        def register(event)
+          raise ArgumentError, "Block is required!" unless block_given?
+          registrations[event] = Proc.new
+        end
+
+        def activate_all(events)
+          events = events.split(",")
+          events.each { |event| try_activate(event) }
+        end
+
+        def try_activate(event)
+          return unless registrations.key?(event)
+          registrations.delete(event).call
+        end
+
+        private
+
+        def registrations
+          @registrations ||= {}
+        end
+      end
+    end
+  end
+end
+
 require "test_prof/event_prof/custom_events/factory_create"
 require "test_prof/event_prof/custom_events/sidekiq_inline"
 require "test_prof/event_prof/custom_events/sidekiq_jobs"

data/lib/test_prof/event_prof/minitest.rb

@@ -9,6 +9,9 @@ module Minitest
       def initialize(io = $stdout, options = {})
         super
         @profiler = configure_profiler(options)
+
+        log :info, "EventProf enabled (#{@profiler.events.join(', ')})"
+
         @formatter = EventProfFormatter.new(@profiler)
         @current_group = nil
         @current_example = nil
@@ -64,7 +67,10 @@ module Minitest
           config.rank_by = options[:rank_by] if options[:rank_by]
           config.top_count = options[:top_count] if options[:top_count]
           config.per_example = options[:per_example] if options[:per_example]
+
+          ::TestProf::EventProf::CustomEvents.activate_all config.event
         end
+
         ::TestProf::EventProf.build
       end
     end

data/lib/test_prof/event_prof/profiler.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module TestProf
+  module EventProf
+    class Profiler # :nodoc:
+      attr_reader :event, :total_count, :total_time, :rank_by, :top_count, :per_example,
+                  :time, :count, :example_time, :example_count
+
+      alias per_example? per_example
+
+      def initialize(event:, instrumenter:, rank_by: :time, top_count: 5, per_example: false)
+        @event = event
+        @rank_by = rank_by
+        @top_count = top_count
+        @per_example = per_example
+
+        instrumenter.subscribe(event) { |time| track(time) }
+
+        @groups = Utils::SizedOrderedSet.new(
+          top_count, sort_by: rank_by
+        )
+
+        @examples = Utils::SizedOrderedSet.new(
+          top_count, sort_by: rank_by
+        )
+
+        @total_count = 0
+        @total_time = 0.0
+      end
+
+      def track(time)
+        return if @current_group.nil?
+        @total_time += time
+        @total_count += 1
+
+        @time += time
+        @count += 1
+
+        return if @current_example.nil?
+
+        @example_time += time
+        @example_count += 1
+      end
+
+      def group_started(id)
+        reset_group!
+        @current_group = id
+      end
+
+      def group_finished(id)
+        data = { id: id, time: @time, count: @count, examples: @total_examples }
+
+        @groups << data unless data[rank_by].zero?
+
+        @current_group = nil
+      end
+
+      def example_started(id)
+        return unless per_example?
+        reset_example!
+        @current_example = id
+      end
+
+      def example_finished(id)
+        @total_examples += 1
+        return unless per_example?
+
+        data = { id: id, time: @example_time, count: @example_count }
+        @examples << data unless data[rank_by].zero?
+        @current_example = nil
+      end
+
+      def results
+        {
+          groups: @groups.to_a
+        }.tap do |data|
+          next unless per_example?
+
+          data[:examples] = @examples.to_a
+        end
+      end
+
+      private
+
+      def reset_group!
+        @time = 0.0
+        @count = 0
+        @total_examples = 0
+      end
+
+      def reset_example!
+        @example_count = 0
+        @example_time = 0.0
+      end
+    end
+
+    # Multiple profilers wrapper
+    class ProfilersGroup
+      attr_reader :profilers
+
+      def initialize(event:, **options)
+        events = event.split(",")
+        @profilers = events.map do |ev|
+          Profiler.new(event: ev, **options)
+        end
+      end
+
+      def each
+        if block_given?
+          @profilers.each(&Proc.new)
+        else
+          @profilers.each
+        end
+      end
+
+      def events
+        @profilers.map(&:event)
+      end
+
+      %i[group_started group_finished example_started example_finished].each do |name|
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}(id)
+            @profilers.each { |profiler| profiler.#{name}(id) }
+          end
+        CODE
+      end
+    end
+  end
+end

data/lib/test_prof/event_prof/rspec.rb

@@ -23,6 +23,8 @@ module TestProf
 
       def initialize
         @profiler = EventProf.build
+
+        log :info, "EventProf enabled (#{@profiler.events.join(', ')})"
       end
 
       def example_group_started(notification)
@@ -49,18 +51,22 @@ module TestProf
       alias example_pending example_finished
 
       def print
-        result = @profiler.results
+        @profiler.each(&method(:report))
+      end
+
+      def report(profiler)
+        result = profiler.results
 
         msgs = []
 
         msgs <<
           <<-MSG.strip_heredoc
-            EventProf results for #{@profiler.event}
+            EventProf results for #{profiler.event}
 
-            Total time: #{@profiler.total_time.duration}
-            Total events: #{@profiler.total_count}
+            Total time: #{profiler.total_time.duration}
+            Total events: #{profiler.total_count}
 
-            Top #{@profiler.top_count} slowest suites (by #{@profiler.rank_by}):
+            Top #{profiler.top_count} slowest suites (by #{profiler.rank_by}):
 
           MSG
 
@@ -75,7 +81,7 @@ module TestProf
         end
 
         if result[:examples]
-          msgs << "\nTop #{@profiler.top_count} slowest tests (by #{@profiler.rank_by}):\n\n"
+          msgs << "\nTop #{profiler.top_count} slowest tests (by #{profiler.rank_by}):\n\n"
 
           result[:examples].each do |example|
             description = example[:id].description
@@ -89,11 +95,11 @@ module TestProf
 
         log :info, msgs.join
 
-        stamp! if EventProf.config.stamp?
+        stamp!(profiler) if EventProf.config.stamp?
       end
 
-      def stamp!
-        result = @profiler.results
+      def stamp!(profiler)
+        result = profiler.results
 
         stamper = RSpecStamp::Stamper.new
 
@@ -130,15 +136,18 @@ end
 
 # Register EventProf listener
 TestProf.activate('EVENT_PROF') do
+  TestProf::EventProf::CustomEvents.activate_all(ENV['EVENT_PROF'])
+
   RSpec.configure do |config|
-    listener = TestProf::EventProf::RSpecListener.new
+    listener = nil
 
     config.before(:suite) do
+      listener = TestProf::EventProf::RSpecListener.new
       config.reporter.register_listener(
         listener, *TestProf::EventProf::RSpecListener::NOTIFICATIONS
       )
     end
 
-    config.after(:suite) { listener.print }
+    config.after(:suite) { listener.print unless listener.nil? }
   end
 end

data/lib/test_prof/event_prof.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "test_prof/rspec_stamp"
+require "test_prof/event_prof/profiler"
 require "test_prof/event_prof/instrumentations/active_support"
 require "test_prof/utils/sized_ordered_set"
 
@@ -72,119 +73,20 @@ module TestProf
         yield config
       end
 
-      # Returns new configured instance of profiler
-      def build
-        Profiler.new(
-          event: config.event,
-          instrumenter: config.resolve_instrumenter
+      # Returns new configured instance of profilers group
+      def build(event = config.event)
+        ProfilersGroup.new(
+          event: event,
+          instrumenter: config.resolve_instrumenter,
+          rank_by: config.rank_by,
+          top_count: config.top_count,
+          per_example: config.per_example?
         )
       end
     end
-
-    class Profiler # :nodoc:
-      include TestProf::Logging
-
-      attr_reader :event, :total_count, :total_time
-
-      def initialize(event:, instrumenter:)
-        @event = event
-
-        log :info, "EventProf enabled (#{@event})"
-
-        instrumenter.subscribe(event) { |time| track(time) }
-
-        @groups = Utils::SizedOrderedSet.new(
-          top_count, sort_by: rank_by
-        )
-
-        @examples = Utils::SizedOrderedSet.new(
-          top_count, sort_by: rank_by
-        )
-
-        @total_count = 0
-        @total_time = 0.0
-      end
-
-      def track(time)
-        return if @current_group.nil?
-        @total_time += time
-        @total_count += 1
-
-        @time += time
-        @count += 1
-
-        return if @current_example.nil?
-
-        @example_time += time
-        @example_count += 1
-      end
-
-      def group_started(id)
-        reset_group!
-        @current_group = id
-      end
-
-      def group_finished(id)
-        data = { id: id, time: @time, count: @count, examples: @total_examples }
-
-        @groups << data unless data[rank_by].zero?
-
-        @current_group = nil
-      end
-
-      def example_started(id)
-        return unless config.per_example?
-        reset_example!
-        @current_example = id
-      end
-
-      def example_finished(id)
-        @total_examples += 1
-        return unless config.per_example?
-
-        data = { id: id, time: @example_time, count: @example_count }
-        @examples << data unless data[rank_by].zero?
-        @current_example = nil
-      end
-
-      def results
-        {
-          groups: @groups.to_a
-        }.tap do |data|
-          next unless config.per_example?
-
-          data[:examples] = @examples.to_a
-        end
-      end
-
-      def rank_by
-        EventProf.config.rank_by
-      end
-
-      def top_count
-        EventProf.config.top_count
-      end
-
-      private
-
-      def config
-        EventProf.config
-      end
-
-      def reset_group!
-        @time = 0.0
-        @count = 0
-        @total_examples = 0
-      end
-
-      def reset_example!
-        @example_count = 0
-        @example_time = 0.0
-      end
-    end
   end
 end
 
+require "test_prof/event_prof/custom_events"
 require "test_prof/event_prof/rspec" if defined?(RSpec::Core)
 require "test_prof/event_prof/minitest" if defined?(Minitest)
-require "test_prof/event_prof/custom_events"

data/lib/test_prof/ext/active_record_refind.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Ext
+    # Adds `ActiveRecord::Base#refind` method (through refinement)
+    module ActiveRecordRefind
+      refine ActiveRecord::Base do
+        # Returns new reloaded record.
+        #
+        # Unlike `reload` this method returns
+        # completely re-initialized instance.
+        #
+        # We need it to make sure that the state is clean.
+        def refind
+          self.class.find(send(self.class.primary_key))
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/factory_all_stub/factory_bot_patch.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TestProf
+  module FactoryAllStub
+    # Wrap #run method to override strategy
+    module FactoryBotPatch
+      def run(_strategy = @strategy)
+        return super unless FactoryAllStub.enabled?
+        super(:build_stubbed)
+      end
+    end
+  end
+end