test-prof 0.1.0.beta1

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module TestProf::EventProf::CustomEvents
+  module SidekiqJobs # :nodoc: all
+    module ClientPatch
+      def raw_push(*)
+        return super unless Sidekiq::Testing.inline?
+        SidekiqJobs.track { super }
+      end
+    end
+
+    class << self
+      def setup!
+        Sidekiq::Client.prepend ClientPatch
+      end
+
+      def track
+        ActiveSupport::Notifications.instrument(
+          'sidekiq.jobs'
+        ) { yield }
+      end
+    end
+  end
+end
+
+if TestProf.require(
+  'sidekiq/testing',
+  <<~MSG
+    Failed to load Sidekiq.
+
+    Make sure that "sidekiq" gem is in your Gemfile.
+  MSG
+)
+  TestProf::EventProf::CustomEvents::SidekiqJobs.setup!
+  TestProf::EventProf.configure do |config|
+    config.rank_by = :count
+  end
+end

data/lib/test_prof/event_prof/custom_events.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "test_prof/event_prof/custom_events/factory_create" if ENV['EVENT_PROF'] == "factory.create"
+require "test_prof/event_prof/custom_events/sidekiq_inline" if ENV['EVENT_PROF'] == "sidekiq.inline"
+require "test_prof/event_prof/custom_events/sidekiq_jobs" if ENV['EVENT_PROF'] == "sidekiq.jobs"

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module TestProf::EventProf
+  module Instrumentations
+    # Wrapper over ActiveSupport::Notifications
+    module ActiveSupport
+      def self.subscribe(event)
+        raise ArgumentError, 'Block is required!' unless block_given?
+
+        ::ActiveSupport::Notifications.subscribe(event) do |_event, start, finish, *_args|
+          yield (finish - start)
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/event_prof/minitest.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+# TODO: write Minitest reporter

data/lib/test_prof/event_prof/rspec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "test_prof/ext/float_duration"
+
+module TestProf
+  module EventProf
+    class RSpecListener # :nodoc:
+      include Logging
+      using FloatDuration
+
+      NOTIFICATIONS = %i[
+        example_group_started
+        example_group_finished
+        example_started
+        example_finished
+      ].freeze
+
+      def initialize
+        @profiler = EventProf.build
+      end
+
+      def example_group_started(notification)
+        return unless notification.group.top_level?
+        @profiler.group_started notification.group
+      end
+
+      def example_group_finished(notification)
+        return unless notification.group.top_level?
+        @profiler.group_finished notification.group
+      end
+
+      def example_started(notification)
+        @profiler.example_started notification.example
+      end
+
+      def example_finished(notification)
+        @profiler.example_finished notification.example
+      end
+
+      def print
+        result = @profiler.results
+
+        msgs = []
+
+        msgs <<
+          <<~MSG
+            EventProf results for #{@profiler.event}
+
+            Total time: #{@profiler.total_time.duration}
+            Total events: #{@profiler.total_count}
+
+            Top #{@profiler.top_count} slowest suites (by #{@profiler.rank_by}):
+
+          MSG
+
+        result[:groups].each do |group|
+          description = group[:id].top_level_description
+          location = group[:id].metadata[:location]
+
+          msgs <<
+            <<~GROUP
+              #{description} (#{location}) – #{group[:time].duration} (#{group[:count]} / #{group[:examples]})
+            GROUP
+        end
+
+        if result[:examples]
+          msgs << "\nTop #{@profiler.top_count} slowest tests (by #{@profiler.rank_by}):\n\n"
+
+          result[:examples].each do |example|
+            description = example[:id].description
+            location = example[:id].metadata[:location]
+            msgs <<
+              <<~GROUP
+                #{description} (#{location}) – #{example[:time].duration} (#{example[:count]})
+              GROUP
+          end
+        end
+
+        log :info, msgs.join
+      end
+    end
+  end
+end
+
+# Register EventProf listener
+TestProf.activate('EVENT_PROF') do
+  RSpec.configure do |config|
+    listener = TestProf::EventProf::RSpecListener.new
+
+    config.reporter.register_listener(listener, *TestProf::EventProf::RSpecListener::NOTIFICATIONS)
+
+    config.after(:suite) { listener.print }
+  end
+end

data/lib/test_prof/event_prof.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "test_prof/event_prof/instrumentations/active_support"
+
+module TestProf
+  # EventProf profiles your tests and suites against custom events,
+  # such as ActiveSupport::Notifacations.
+  #
+  # It works very similar to `rspec --profile` but can track arbitrary events.
+  #
+  # Example:
+  #
+  #   # Collect SQL queries stats for every suite and example
+  #   EVENT_PROF='sql.active_record' rspec ...
+  #
+  # By default it collects information only about top-level groups (aka suites),
+  # but you can also profile individual examples. Just set the configuration option:
+  #
+  #  TestProf::EventProf.configure do |config|
+  #    config.per_example = true
+  #  end
+  module EventProf
+    # EventProf configuration
+    class Configuration
+      # Map of supported instrumenters
+      INSTRUMENTERS = {
+        active_support: 'ActiveSupport'
+      }.freeze
+
+      attr_accessor :instrumenter, :top_count, :per_example,
+                    :rank_by, :event
+
+      def initialize
+        @event = ENV['EVENT_PROF']
+        @instrumenter = :active_support
+        @top_count = (ENV['EVENT_PROF_TOP'] || 5).to_i
+        @per_example = false
+        @rank_by = (ENV['EVENT_PROF_RANK'] || :time).to_sym
+      end
+
+      def per_example?
+        per_example == true
+      end
+
+      def resolve_instrumenter
+        return instrumenter if instrumenter.is_a?(Module)
+
+        raise ArgumentError, "Unknown instrumenter: #{instrumenter}" unless
+          INSTRUMENTERS.key?(instrumenter)
+
+        Instrumentations.const_get(INSTRUMENTERS[instrumenter])
+      end
+    end
+
+    class << self
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
+      # Returns new configured instance of profiler
+      def build
+        Profiler.new(
+          event: config.event,
+          instrumenter: config.resolve_instrumenter
+        )
+      end
+    end
+
+    class Profiler # :nodoc:
+      include TestProf::Logging
+
+      attr_reader :event, :top_count, :rank_by, :total_count, :total_time
+
+      def initialize(event:, instrumenter:)
+        @event = event
+
+        log :info, "EventProf enabled (#{@event})"
+
+        instrumenter.subscribe(event) { |time| track(time) }
+
+        @groups = Hash.new { |h, k| h[k] = { id: k } }
+        @examples = Hash.new { |h, k| h[k] = { id: k } }
+
+        @total_count = 0
+        @total_time = 0.0
+
+        reset!
+      end
+
+      def track(time)
+        return if @current_group.nil?
+        @total_time += time
+        @total_count += 1
+
+        @time += time
+        @count += 1
+
+        @example_time += time if config.per_example?
+        @example_count += 1 if config.per_example?
+      end
+
+      def group_started(id)
+        reset!
+        @current_group = id
+      end
+
+      def group_finished(id)
+        @groups[id][:time] = @time
+        @groups[id][:count] = @count
+        @groups[id][:examples] = @total_examples
+        @current_group = nil
+      end
+
+      def example_started(_id)
+        reset_example!
+      end
+
+      def example_finished(id)
+        @total_examples += 1
+        return unless config.per_example?
+
+        @examples[id][:time] = @example_time
+        @examples[id][:count] = @example_count
+      end
+
+      def results
+        {
+          groups: fetch_top(@groups.values)
+        }.tap do |data|
+          next unless config.per_example?
+
+          data[:examples] = fetch_top(@examples.values)
+        end
+      end
+
+      def rank_by
+        EventProf.config.rank_by
+      end
+
+      def top_count
+        EventProf.config.top_count
+      end
+
+      private
+
+      def fetch_top(arr)
+        arr.reject { |el| el[rank_by].zero? }
+           .sort_by { |el| -el[rank_by] }
+           .take(top_count)
+      end
+
+      def config
+        EventProf.config
+      end
+
+      def reset!
+        @time = 0.0
+        @count = 0
+        @total_examples = 0
+        reset_example!
+      end
+
+      def reset_example!
+        @example_count = 0
+        @example_time = 0.0
+      end
+    end
+  end
+end
+
+require "test_prof/event_prof/rspec" if defined?(RSpec)
+require "test_prof/event_prof/minitest" if defined?(Minitest::Reporters)
+require "test_prof/event_prof/custom_events"

data/lib/test_prof/ext/float_duration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Add #duration method to floats
+module TestProf
+  # Extend Float with #duration method
+  module FloatDuration
+    refine Float do
+      def duration
+        t = self
+        format("%02d:%02d.%03d", t / 60, t % 60, t.modulo(1) * 1000)
+      end
+    end
+  end
+end

data/lib/test_prof/factory_doctor/factory_girl_patch.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module TestProf
+  module FactoryDoctor
+    # Wrap #run method with FactoryDoctor tracking
+    module FactoryGirlPatch
+      def run(strategy = @strategy)
+        FactoryDoctor.within_factory(strategy) { super }
+      end
+    end
+  end
+end

data/lib/test_prof/factory_doctor/minitest.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+# TODO: write Minitest reporter

data/lib/test_prof/factory_doctor/rspec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "test_prof/ext/float_duration"
+
+module TestProf
+  module FactoryDoctor
+    class RSpecListener # :nodoc:
+      include Logging
+      using FloatDuration
+
+      NOTIFICATIONS = %i[
+        example_started
+        example_finished
+      ].freeze
+
+      def initialize
+        @count = 0
+        @time = 0.0
+        @example_groups = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def example_started(_notification)
+        FactoryDoctor.start
+      end
+
+      def example_finished(notification)
+        FactoryDoctor.stop
+        return if notification.example.pending?
+
+        result = FactoryDoctor.result
+
+        return unless result.bad?
+
+        group = notification.example.example_group.parent_groups.last
+        notification.example.metadata.merge!(
+          factories: result.count,
+          time: result.time
+        )
+        @example_groups[group] << notification.example
+        @count += 1
+        @time += result.time
+      end
+
+      def print
+        return if @example_groups.empty?
+
+        msgs = []
+
+        msgs <<
+          <<~MSG
+            FactoryDoctor report
+
+            Total (potentially) bad examples: #{@count}
+            Total wasted time: #{@time.duration}
+
+          MSG
+
+        @example_groups.each do |group, examples|
+          msgs << "#{group.description} (#{group.metadata[:location]})\n"
+          examples.each do |ex|
+            msgs << "  #{ex.description} (#{ex.metadata[:location]}) "\
+                    "– #{pluralize_records(ex.metadata[:factories])} created, "\
+                    "#{ex.metadata[:time].duration}\n"
+          end
+          msgs << "\n"
+        end
+
+        log :info, msgs.join
+      end
+
+      private
+
+      def pluralize_records(count)
+        return "1 record" if count == 1
+        "#{count} records"
+      end
+    end
+  end
+end
+
+# Register FactoryDoctor listener
+TestProf.activate('FDOC') do
+  RSpec.configure do |config|
+    listener = TestProf::FactoryDoctor::RSpecListener.new
+
+    config.reporter.register_listener(
+      listener, *TestProf::FactoryDoctor::RSpecListener::NOTIFICATIONS
+    )
+
+    config.after(:suite) { listener.print }
+  end
+
+  RSpec.shared_context "factory_doctor:ignore", fd_ignore: true do
+    around(:each) { |ex| TestProf::FactoryDoctor.ignore(&ex) }
+  end
+end