test-prof 0.2.1 → 0.3.0

data/lib/test_prof/ext/array_bsearch_index.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module TestProf
+  # Ruby 2.3 #bsearch_index method (for usage with older Rubies)
+  # Straighforward and non-optimal implementation,
+  # just for compatiblity
+  module ArrayBSearchIndex
+    refine Array do
+      def bsearch_index(&block)
+        el = bsearch(&block)
+        index(el)
+      end
+    end
+  end
+end

data/lib/test_prof/ext/float_duration.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# Add #duration method to floats
 module TestProf
   # Extend Float with #duration method
   module FloatDuration

data/lib/test_prof/ext/string_strip_heredoc.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module TestProf
+  # Add #strip_heredoc method to use instead of
+  # squiggly docs (to support older Rubies)
+  module StringStripHeredoc
+    refine String do
+      def strip_heredoc
+        min = scan(/^[ \t]*(?=\S)/).min
+        indent = min ? min.size : 0
+        gsub(/^[ \t]{#{indent}}/, '')
+      end
+    end
+  end
+end

data/lib/test_prof/ext/string_truncate.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module TestProf
+  # Extend String with #truncate method
+  module StringTruncate
+    refine String do
+      # Truncate to the specified limit
+      # by replacing middle part with dots
+      def truncate(limit = 30)
+        return self unless size > limit
+
+        head = ((limit - 3) / 2)
+        tail = head + 3 - limit
+
+        "#{self[0..(head - 1)]}...#{self[tail..-1]}"
+      end
+    end
+  end
+end

data/lib/test_prof/factory_doctor/rspec.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
 require "test_prof/ext/float_duration"
+require "test_prof/ext/string_strip_heredoc"
 
 module TestProf
   module FactoryDoctor
     class RSpecListener # :nodoc:
       include Logging
       using FloatDuration
+      using StringStripHeredoc
 
-      SUCCESS_MESSAGE = 'FactoryDoctor says: "Looks good to me!"'
+      SUCCESS_MESSAGE = 'FactoryDoctor says: "Looks good to me!"'.freeze
 
       NOTIFICATIONS = %i[
         example_started
@@ -49,7 +51,7 @@ module TestProf
         msgs = []
 
         msgs <<
-          <<~MSG
+          <<-MSG.strip_heredoc
             FactoryDoctor report
 
             Total (potentially) bad examples: #{@count}
@@ -68,6 +70,40 @@ module TestProf
         end
 
         log :info, msgs.join
+
+        stamp! if FactoryDoctor.stamp?
+      end
+
+      def stamp!
+        stamper = RSpecStamp::Stamper.new
+
+        examples = Hash.new { |h, k| h[k] = [] }
+
+        @example_groups.each_value do |bad_examples|
+          bad_examples.each do |example|
+            file, line = example.metadata[:location].split(":")
+            examples[file] << line.to_i
+          end
+        end
+
+        examples.each do |file, lines|
+          stamper.stamp_file(file, lines.uniq)
+        end
+
+        msgs = []
+
+        msgs <<
+          <<-MSG.strip_heredoc
+            RSpec Stamp results
+
+            Total patches: #{stamper.total}
+            Total files: #{examples.keys.size}
+
+            Failed patches: #{stamper.failed}
+            Ignored files: #{stamper.ignored}
+          MSG
+
+        log :info, msgs.join
       end
 
       private

data/lib/test_prof/factory_doctor.rb

@@ -16,7 +16,7 @@ module TestProf
       end
 
       def bad?
-        count.positive? && queries_count.zero?
+        count > 0 && queries_count.zero?
       end
     end
 
@@ -54,6 +54,14 @@ module TestProf
           defined?(::FactoryGirl)
 
         subscribe!
+
+        @stamp = ENV['FDOC_STAMP']
+
+        RSpecStamp.config.tags = @stamp if stamp?
+      end
+
+      def stamp?
+        !@stamp.nil?
       end
 
       def start
@@ -82,14 +90,14 @@ module TestProf
         return yield if ignore? || !running? || (strategy != :create)
 
         begin
-          ts = Time.now if @depth.zero?
+          ts = TestProf.now if @depth.zero?
           @depth += 1
           @count += 1
           yield
         ensure
           @depth -= 1
 
-          @time += (Time.now - ts) if @depth.zero?
+          @time += (TestProf.now - ts) if @depth.zero?
         end
       end
 
@@ -111,7 +119,7 @@ module TestProf
       end
 
       def within_factory?
-        @depth.positive?
+        @depth > 0
       end
 
       def ignore?

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

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
+require "test_prof/ext/string_strip_heredoc"
+
 module TestProf::FactoryProf
   module Printers
     module Simple # :nodoc: all
       class << self
         include TestProf::Logging
+        using TestProf::StringStripHeredoc
 
         def dump(result)
           msgs = []
 
           msgs <<
-            <<~MSG
+            <<-MSG.strip_heredoc
               Factories usage
 
                total      top-level                            name

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

@@ -12,7 +12,7 @@ RSpec.shared_context "any_fixture:clean", with_clean_fixture: true do
 
   def open_transaction?
     pool = ActiveRecord::Base.connection_pool
-    pool.active_connection? && pool.connection.open_transactions.positive?
+    pool.active_connection? && pool.connection.open_transactions > 0
   end
 end
 

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

@@ -6,6 +6,10 @@ module TestProf
     def before_all(&block)
       raise ArgumentError, "Block is required!" unless block_given?
 
+      return if within_before_all?
+
+      @__before_all_activated__ = true
+
       before(:all) do
         ActiveRecord::Base.connection.begin_transaction(joinable: false)
         instance_eval(&block)
@@ -15,6 +19,10 @@ module TestProf
         ActiveRecord::Base.connection.rollback_transaction
       end
     end
+
+    def within_before_all?
+      instance_variable_defined?(:@__before_all_activated__)
+    end
   end
 end
 

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "./before_all"
+
+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 << self
+      def module_for(group)
+        modules.fetch(group) do
+          Module.new.tap { |mod| group.prepend(mod) }
+        end
+      end
+
+      private
+
+      def modules
+        @modules ||= {}
+      end
+    end
+    # 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__".freeze : "@😸".freeze
+
+    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)
+      else
+        before_all(&initializer)
+      end
+
+      define_let_it_be_methods(identifier, **options)
+    end
+
+    def define_let_it_be_methods(identifier, reload: false, refind: false)
+      let_accessor = -> { instance_variable_get(:"#{PREFIX}#{identifier}") }
+
+      if reload
+        let_accessor = lambda do
+          record = instance_variable_get(:"#{PREFIX}#{identifier}")
+          next unless record.is_a?(::ActiveRecord::Base)
+          record.reload
+        end
+      end
+
+      if refind
+        let_accessor = lambda do
+          record = instance_variable_get(:"#{PREFIX}#{identifier}")
+          next unless record.is_a?(::ActiveRecord::Base)
+
+          record.class.find(record.send(record.class.primary_key))
+        end
+      end
+
+      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\)/
+            instance_variable_get(:"#{PREFIX}#{identifier}")
+          else
+            # Fallback to let definition
+            super()
+          end
+        end
+      end
+
+      let(identifier, &let_accessor)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.extend TestProf::LetItBe
+end

data/lib/test_prof/rspec_dissect/rspec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "test_prof/ext/float_duration"
+require "test_prof/ext/string_truncate"
+require "test_prof/utils/sized_ordered_set"
+require "test_prof/ext/string_strip_heredoc"
+
+module TestProf
+  module RSpecDissect
+    class Listener # :nodoc:
+      include Logging
+      using FloatDuration
+      using StringTruncate
+      using StringStripHeredoc
+
+      NOTIFICATIONS = %i[
+        example_finished
+        example_group_finished
+      ].freeze
+
+      def initialize
+        @before_results = Utils::SizedOrderedSet.new(
+          top_count, sort_by: :before
+        )
+        @memo_results = Utils::SizedOrderedSet.new(
+          top_count, sort_by: :memo
+        )
+        @examples_count = 0
+        @examples_time = 0.0
+        @total_examples_time = 0.0
+      end
+
+      def example_finished(notification)
+        @examples_count += 1
+        @examples_time += notification.example.execution_result.run_time
+      end
+
+      def example_group_finished(notification)
+        return unless notification.group.top_level?
+
+        data = {}
+        data[:total] = @examples_time
+        data[:count] = @examples_count
+        data[:before] = RSpecDissect.before_time
+        data[:memo] = RSpecDissect.memo_time
+        data[:desc] = notification.group.top_level_description
+        data[:loc] = notification.group.metadata[:location]
+
+        @before_results << data
+        @memo_results << data
+
+        @total_examples_time += @examples_time
+        @examples_count = 0
+        @examples_time = 0.0
+
+        RSpecDissect.reset!
+      end
+
+      def print
+        msgs = []
+
+        msgs <<
+          <<-MSG.strip_heredoc
+            RSpecDissect report
+
+            Total time: #{@total_examples_time.duration}
+            Total `before(:each)` time: #{RSpecDissect.total_before_time.duration}
+            Total `let` time: #{RSpecDissect.total_memo_time.duration}
+
+          MSG
+
+        msgs <<
+          <<-MSG.strip_heredoc
+            Top #{top_count} slowest suites (by `before(:each)` time):
+
+          MSG
+
+        @before_results.each do |group|
+          msgs <<
+            <<-GROUP.strip_heredoc
+              #{group[:desc].truncate} (#{group[:loc]}) – #{group[:before].duration} of #{group[:total].duration} (#{group[:count]})
+            GROUP
+        end
+
+        msgs <<
+          <<-MSG.strip_heredoc
+
+            Top #{top_count} slowest suites (by `let` time):
+
+          MSG
+
+        @memo_results.each do |group|
+          msgs <<
+            <<-GROUP.strip_heredoc
+              #{group[:desc].truncate} (#{group[:loc]}) – #{group[:memo].duration} of #{group[:total].duration} (#{group[:count]})
+            GROUP
+        end
+
+        log :info, msgs.join
+
+        stamp! if RSpecDissect.config.stamp?
+      end
+
+      def stamp!
+        stamper = RSpecStamp::Stamper.new
+
+        examples = Hash.new { |h, k| h[k] = [] }
+
+        (@before_results.to_a + @memo_results.to_a)
+          .map { |obj| obj[:loc] }.each do |location|
+          file, line = location.split(":")
+          examples[file] << line.to_i
+        end
+
+        examples.each do |file, lines|
+          stamper.stamp_file(file, lines.uniq)
+        end
+
+        msgs = []
+
+        msgs <<
+          <<-MSG.strip_heredoc
+            RSpec Stamp results
+
+            Total patches: #{stamper.total}
+            Total files: #{examples.keys.size}
+
+            Failed patches: #{stamper.failed}
+            Ignored files: #{stamper.ignored}
+          MSG
+
+        log :info, msgs.join
+      end
+
+      private
+
+      def top_count
+        RSpecDissect.config.top_count
+      end
+    end
+  end
+end
+
+# Register RSpecDissect listener
+TestProf.activate('RD_PROF') do
+  RSpec.configure do |config|
+    listener = TestProf::RSpecDissect::Listener.new
+
+    config.before(:suite) do
+      config.reporter.register_listener(
+        listener, *TestProf::RSpecDissect::Listener::NOTIFICATIONS
+      )
+    end
+
+    config.after(:suite) { listener.print }
+  end
+end

data/lib/test_prof/rspec_dissect.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "test_prof/rspec_stamp"
+require "test_prof/logging"
+
+module TestProf
+  # RSpecDissect tracks how much time do you spend in `before` hooks
+  # and memoization helpers (i.e. `let`) in your tests.
+  module RSpecDissect
+    module ExampleInstrumentation # :nodoc:
+      def run_before_example(*)
+        RSpecDissect.track(:before) { super }
+      end
+    end
+
+    module MemoizedInstrumentation # :nodoc:
+      def fetch_or_store(*)
+        res = nil
+        Thread.current[:_rspec_dissect_memo_depth] ||= 0
+        Thread.current[:_rspec_dissect_memo_depth] += 1
+        begin
+          res = if Thread.current[:_rspec_dissect_memo_depth] == 1
+                  RSpecDissect.track(:memo) { super }
+                else
+                  super
+                end
+        ensure
+          Thread.current[:_rspec_dissect_memo_depth] -= 1
+        end
+        res
+      end
+    end
+
+    # RSpecDisect configuration
+    class Configuration
+      attr_accessor :top_count
+
+      def initialize
+        @top_count = (ENV['RD_PROF_TOP'] || 5).to_i
+        @stamp = ENV['RD_PROF_STAMP']
+
+        RSpecStamp.config.tags = @stamp if stamp?
+      end
+
+      def stamp?
+        !@stamp.nil?
+      end
+    end
+
+    METRICS = %w[before memo].freeze
+
+    class << self
+      include Logging
+
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
+      def init
+        RSpec::Core::Example.prepend(ExampleInstrumentation)
+        RSpec::Core::MemoizedHelpers::ThreadsafeMemoized.prepend(MemoizedInstrumentation)
+        RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized.prepend(MemoizedInstrumentation)
+
+        @data = {}
+
+        METRICS.each do |type|
+          @data["total_#{type}"] = 0.0
+        end
+
+        reset!
+
+        log :info, "RSpecDissect enabled"
+      end
+
+      def track(type)
+        start = TestProf.now
+        res = yield
+        delta = (TestProf.now - start)
+        type = type.to_s
+        @data[type] += delta
+        @data["total_#{type}"] += delta
+        res
+      end
+
+      def reset!
+        METRICS.each do |type|
+          @data[type.to_s] = 0.0
+        end
+      end
+
+      METRICS.each do |type|
+        define_method("#{type}_time") do
+          @data[type.to_s]
+        end
+
+        define_method("total_#{type}_time") do
+          @data["total_#{type}"]
+        end
+      end
+    end
+  end
+end
+
+require "test_prof/rspec_dissect/rspec" if defined?(RSpec::Core)
+
+TestProf.activate('RD_PROF') do
+  TestProf::RSpecDissect.init
+end

data/lib/test_prof/rspec_stamp/parser.rb

@@ -2,15 +2,13 @@
 
 require "ripper"
 
-# rubocop: disable Metrics/CyclomaticComplexity
-
 module TestProf
   module RSpecStamp
     # Parse examples headers
     module Parser
       # Contains the result of parsing
       class Result
-        attr_accessor :fname, :desc
+        attr_accessor :fname, :desc, :desc_const
         attr_reader :tags, :htags
 
         def add_tag(v)
@@ -22,9 +20,16 @@ module TestProf
           @htags ||= []
           @htags << [k, v]
         end
+
+        def remove_tag(tag)
+          @tags.delete(tag) if @tags
+          @htags.delete_if { |(k, _v)| k == tag } if @htags
+        end
       end
 
       class << self
+        # rubocop: disable Metrics/CyclomaticComplexity
+        # rubocop: disable Metrics/PerceivedComplexity
         def parse(code)
           sexp = Ripper.sexp(code)
           return unless sexp
@@ -53,11 +58,17 @@ module TestProf
           res = Result.new
 
           fcall = sexp[1][0][1]
-          fcall = fcall[1] if fcall.first == :fcall
-          res.fname = fcall[1]
-
           args_block = sexp[1][0][2]
 
+          if fcall.first == :fcall
+            fcall = fcall[1]
+          elsif fcall.first == :var_ref
+            res.fname = [parse_const(fcall), sexp[1][0][3][1]].join(".")
+            args_block = sexp[1][0][4]
+          end
+
+          res.fname ||= fcall[1]
+
           return res if args_block.nil?
 
           args_block = args_block[1] if args_block.first == :arg_paren
@@ -66,12 +77,16 @@ module TestProf
 
           if args.first.first == :string_literal
             res.desc = parse_literal(args.shift)
+          elsif args.first.first == :var_ref || args.first.first == :const_path_ref
+            res.desc_const = parse_const(args.shift)
           end
 
           parse_arg(res, args.shift) until args.empty?
 
           res
         end
+        # rubocop: enable Metrics/CyclomaticComplexity
+        # rubocop: enable Metrics/PerceivedComplexity
 
         private
 
@@ -85,7 +100,24 @@ module TestProf
 
         def parse_hash(res, hash_arg)
           hash_arg.each do |(_, label, val)|
-            res.add_htag label[1][0..-2].to_sym, parse_literal(val)
+            res.add_htag label[1][0..-2].to_sym, parse_value(val)
+          end
+        end
+
+        # Expr of the form:
+        #  bool - [:var_ref, [:@kw, "true", [1, 24]]]
+        #  string - [:string_literal, [:string_content, [...]]]
+        #  int - [:@int, "3", [1, 52]]]]
+        def parse_value(expr)
+          case expr.first
+          when :var_ref
+            expr[1][1] == "true"
+          when :@int
+            expr[1].to_i
+          when :@float
+            expr[1].to_f
+          else
+            parse_literal(expr)
           end
         end
 
@@ -97,6 +129,25 @@ module TestProf
                               expr[0] == :assoc_new
           val
         end
+
+        # Expr of the form:
+        #  [:var_ref, [:@const, "User", [1, 9]]]
+        #
+        #  or
+        #
+        #  [:const_path_ref, [:const_path_ref, [:var_ref,
+        #    [:@const, "User", [1, 17]]],
+        #    [:@const, "Guest", [1, 23]]],
+        #    [:@const, "Collection", [1, 30]]
+        def parse_const(expr)
+          if expr.first == :var_ref
+            expr[1][1]
+          elsif expr.first == :@const
+            expr[1]
+          elsif expr.first == :const_path_ref
+            expr[1..-1].map(&method(:parse_const)).join("::")
+          end
+        end
       end
     end
   end