test-prof 0.4.9 → 0.5.0.pre1

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/factory_all_stub.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "test_prof/factory_bot"
+require "test_prof/factory_all_stub/factory_bot_patch"
+
+module TestProf
+  # FactoryAllStub inject into FactoryBot to make
+  # all strategies be `build_stubbed` strategy.
+  module FactoryAllStub
+    LOCAL_NAME = :__factory_bot_stub_all__
+
+    class << self
+      def init
+        # Monkey-patch FactoryBot / FactoryGirl
+        TestProf::FactoryBot::FactoryRunner.prepend(FactoryBotPatch) if
+          defined?(TestProf::FactoryBot)
+      end
+
+      def enabled?
+        Thread.current[LOCAL_NAME] == true
+      end
+
+      def enable!
+        Thread.current[LOCAL_NAME] = true
+      end
+
+      def disable!
+        Thread.current[LOCAL_NAME] = false
+      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

data/lib/test_prof/factory_doctor/rspec.rb

@@ -128,15 +128,16 @@ TestProf.activate('FDOC') do
   TestProf::FactoryDoctor.init
 
   RSpec.configure do |config|
-    listener = TestProf::FactoryDoctor::RSpecListener.new
+    listener = nil
 
     config.before(:suite) do
+      listener = TestProf::FactoryDoctor::RSpecListener.new
       config.reporter.register_listener(
         listener, *TestProf::FactoryDoctor::RSpecListener::NOTIFICATIONS
       )
     end
 
-    config.after(:suite) { listener.print }
+    config.after(:suite) { listener.print unless listener.nil? }
   end
 
   RSpec.shared_context "factory_doctor:ignore", fd_ignore: true do

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

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
-require "json"
+require "test_prof/utils/html_builder"
 
 module TestProf::FactoryProf
   module Printers
     module Flamegraph # :nodoc: all
+      TEMPLATE = "flamegraph.template.html".freeze
+      OUTPUT_NAME = "factory-flame.html".freeze
+
       class << self
         include TestProf::Logging
 
@@ -17,7 +20,11 @@ module TestProf::FactoryProf
 
           report_data[:roots] = convert_stacks(result)
 
-          path = generate_html(report_data)
+          path = TestProf::Utils::HTMLBuilder.generate(
+            data: report_data,
+            template: TEMPLATE,
+            output: OUTPUT_NAME
+          )
 
           log :info, "FactoryFlame report generated: #{path}"
         end
@@ -55,17 +62,6 @@ module TestProf::FactoryProf
 
           res
         end
-
-        private
-
-        def generate_html(data)
-          template = File.read(TestProf.asset_path("flamegraph.template.html"))
-          template.sub! '/**REPORT-DATA**/', data.to_json
-
-          outpath = TestProf.artifact_path("factory-flame.html")
-          File.write(outpath, template)
-          outpath
-        end
       end
     end
   end

data/lib/test_prof/recipes/active_record_shared_connection.rb

@@ -0,0 +1,55 @@
+# 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
+
+      private
+
+      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
+        ActiveRecordSharedConnection.connection || super
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  TestProf::ActiveRecordSharedConnection.enable!
+  ActiveRecord::Base.singleton_class.prepend TestProf::ActiveRecordSharedConnection::Ext
+end

data/lib/test_prof/recipes/logging.rb

@@ -0,0 +1,37 @@
+if defined?(RSpec)
+  RSpec.shared_context "logging:verbose", log: true 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
+    end
+  end
+
+  RSpec.shared_context "logging:active_record", log: :ar do
+    around(:each) do |ex|
+      logger = ActiveRecord::Base.logger
+      ActiveRecord::Base.logger = Logger.new(STDOUT)
+      ex.run
+      ActiveRecord::Base.logger = logger
+    end
+  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)
+end
+
+TestProf.activate("LOG", "ar") do
+  TestProf.log :info, "Active Record verbose logging enabled"
+  ActiveRecord::Base.logger = Logger.new(STDOUT)
+end

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

@@ -17,5 +17,8 @@ RSpec.shared_context "any_fixture:clean", with_clean_fixture: true do
 end
 
 RSpec.configure do |config|
-  config.after(:suite) { TestProf::AnyFixture.reset }
+  config.after(:suite) do
+    TestProf::AnyFixture.report_stats if TestProf::AnyFixture.reporting_enabled?
+    TestProf::AnyFixture.reset
+  end
 end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "test_prof/factory_all_stub"
+
+TestProf::FactoryAllStub.init
+
+RSpec.shared_context "factory:stub", factory: :stub do
+  prepend_before(:all) { TestProf::FactoryAllStub.enable! }
+  append_after(:all) { TestProf::FactoryAllStub.disable! }
+end

data/lib/test_prof/rspec_dissect/rspec.rb

@@ -157,14 +157,16 @@ end
 # Register RSpecDissect listener
 TestProf.activate('RD_PROF') do
   RSpec.configure do |config|
-    listener = TestProf::RSpecDissect::Listener.new
+    listener = nil
 
     config.before(:suite) do
+      listener = TestProf::RSpecDissect::Listener.new
+
       config.reporter.register_listener(
         listener, *TestProf::RSpecDissect::Listener::NOTIFICATIONS
       )
     end
 
-    config.after(:suite) { listener.print }
+    config.after(:suite) { listener.print unless listener.nil? }
   end
 end

data/lib/test_prof/rspec_stamp/rspec.rb

@@ -58,14 +58,15 @@ end
 # Register EventProf listener
 TestProf.activate('RSTAMP') do
   RSpec.configure do |config|
-    listener = TestProf::RSpecStamp::RSpecListener.new
+    listener = nil
 
     config.before(:suite) do
+      listener = TestProf::RSpecStamp::RSpecListener.new
       config.reporter.register_listener(
         listener, *TestProf::RSpecStamp::RSpecListener::NOTIFICATIONS
       )
     end
 
-    config.after(:suite) { listener.stamp! }
+    config.after(:suite) { listener.stamp! unless listener.nil? }
   end
 end

data/lib/test_prof/tag_prof.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "test_prof/tag_prof/result"
+require "test_prof/tag_prof/printers/simple"
+require "test_prof/tag_prof/printers/html"
+
 module TestProf
   module TagProf # :nodoc:
   end

data/lib/test_prof/tag_prof/printers/html.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module TestProf::TagProf
+  module Printers
+    module HTML # :nodoc: all
+      TEMPLATE = "tagprof.template.html".freeze
+      OUTPUT_NAME = "tag-prof.html".freeze
+
+      class << self
+        include TestProf::Logging
+
+        def dump(result)
+          path = TestProf::Utils::HTMLBuilder.generate(
+            data: result,
+            template: TEMPLATE,
+            output: OUTPUT_NAME
+          )
+
+          log :info, "TagProf report generated: #{path}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "test_prof/ext/float_duration"
+require "test_prof/ext/string_strip_heredoc"
+
+module TestProf::TagProf
+  module Printers
+    module Simple # :nodoc: all
+      class << self
+        include TestProf::Logging
+        using TestProf::StringStripHeredoc
+        using TestProf::FloatDuration
+
+        def dump(result)
+          msgs = []
+
+          msgs <<
+            <<-MSG.strip_heredoc
+              TagProf report for #{result.tag}
+            MSG
+
+          header = []
+
+          header << format(
+            '%15s  %12s  ',
+            result.tag, 'time'
+          )
+
+          events_format = nil
+
+          unless result.events.empty?
+            events_format = result.events.map { |event| "%#{event.size + 2}s  " }.join
+
+            header << format(
+              events_format,
+              *result.events
+            )
+          end
+
+          header << format(
+            '%6s  %6s  %6s  %12s',
+            'total', '%total', '%time', 'avg'
+          )
+
+          msgs << header.join
+
+          msgs << ""
+
+          total = result.data.values.inject(0) { |acc, v| acc + v[:count] }
+          total_time = result.data.values.inject(0) { |acc, v| acc + v[:time] }
+
+          result.data.values.sort_by { |v| -v[:time] }.each do |tag|
+            line = []
+            line << format(
+              "%15s  %12s  ",
+              tag[:value], tag[:time].duration
+            )
+
+            unless result.events.empty?
+              line << format(
+                events_format,
+                *result.events.map { |event| tag[event].duration }
+              )
+            end
+
+            line << format(
+              "%6d  %6.2f  %6.2f  %12s",
+              tag[:count],
+              100 * tag[:count].to_f / total,
+              100 * tag[:time] / total_time,
+              (tag[:time] / tag[:count]).duration
+            )
+
+            msgs << line.join
+          end
+
+          log :info, msgs.join("\n")
+        end
+      end
+    end
+  end
+end