test-prof 0.1.0.beta1

data/lib/test_prof/factory_doctor.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "test_prof/factory_doctor/factory_girl_patch"
+
+module TestProf
+  # FactoryDoctor is a tool that helps you identify
+  # tests that perform unnecessary database queries.
+  module FactoryDoctor
+    class Result # :nodoc:
+      attr_reader :count, :time, :queries_count
+
+      def initialize(count, time, queries_count)
+        @count = count
+        @time = time
+        @queries_count = queries_count
+      end
+
+      def bad?
+        count.positive? && queries_count.zero?
+      end
+    end
+
+    IGNORED_QUERIES_PATTERN = %r{(
+      pg_table|
+      pg_attribute|
+      pg_namespace|
+      show\stables|
+      pragma|
+      sqlite_master/rollback|
+      \ATRUNCATE TABLE|
+      \AALTER TABLE|
+      \ABEGIN|
+      \ACOMMIT|
+      \AROLLBACK|
+      \ARELEASE|
+      \ASAVEPOINT
+    )}xi
+
+    class << self
+      include TestProf::Logging
+
+      attr_reader :event
+      attr_reader :count, :time, :queries_count
+
+      # Patch factory lib, init counters
+      def init(event = 'sql.active_record')
+        @event = event
+        reset!
+
+        log :info, "FactoryDoctor enabled"
+
+        # Monkey-patch FactoryGirl
+        ::FactoryGirl::FactoryRunner.prepend(FactoryGirlPatch) if
+          defined?(::FactoryGirl)
+
+        subscribe!
+      end
+
+      def start
+        reset!
+        @running = true
+      end
+
+      def stop
+        @running = false
+      end
+
+      def result
+        Result.new(count, time, queries_count)
+      end
+
+      # Do not analyze code within the block
+      def ignore
+        @ignored = true
+        res = yield
+      ensure
+        @ignored = false
+        res
+      end
+
+      def within_factory(strategy)
+        return yield if ignore? || !running? || (strategy != :create)
+
+        begin
+          ts = Time.now if @depth.zero?
+          @depth += 1
+          @count += 1
+          yield
+        ensure
+          @depth -= 1
+
+          @time += (Time.now - ts) if @depth.zero?
+        end
+      end
+
+      private
+
+      def reset!
+        @depth = 0
+        @time = 0.0
+        @count = 0
+        @queries_count = 0
+      end
+
+      def subscribe!
+        ::ActiveSupport::Notifications.subscribe(event) do |_name, _start, _finish, _id, query|
+          next if ignore? || !running? || within_factory?
+          next if query[:sql] =~ IGNORED_QUERIES_PATTERN
+          @queries_count += 1
+        end
+      end
+
+      def within_factory?
+        @depth.positive?
+      end
+
+      def ignore?
+        @ignored == true
+      end
+
+      def running?
+        @running == true
+      end
+    end
+  end
+end
+
+require "test_prof/factory_doctor/rspec" if defined?(RSpec)
+require "test_prof/factory_doctor/minitest" if defined?(Minitest::Reporters)
+
+TestProf.activate('FDOC') do
+  TestProf::FactoryDoctor.init
+end

data/lib/test_prof/factory_prof/factory_girl_patch.rb

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

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+
+module TestProf::FactoryProf
+  module Printers
+    module Flamegraph # :nodoc: all
+      class << self
+        include TestProf::Logging
+
+        def dump(result)
+          report_data = {
+            total_stacks: result.stacks.size,
+            total: result.total
+          }
+
+          report_data[:roots] = convert_stacks(result)
+
+          path = generate_html(report_data)
+
+          log :info, "FactoryFlame report generated: #{path}"
+        end
+
+        def convert_stacks(result)
+          res = []
+
+          paths = {}
+
+          result.stacks.each do |stack|
+            parent = nil
+            path = ""
+
+            stack.each do |sample|
+              path = "#{path}/#{sample}"
+
+              if paths[path]
+                node = paths[path]
+                node[:value] += 1
+              else
+                node = { name: sample, value: 1, total: result.raw_stats.fetch(sample)[:total] }
+                paths[path] = node
+
+                if parent.nil?
+                  res << node
+                else
+                  parent[:children] ||= []
+                  parent[:children] << node
+                end
+              end
+
+              parent = node
+            end
+          end
+
+          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.artefact_path("factory-flame.html")
+          File.write(outpath, template)
+          outpath
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module TestProf::FactoryProf
+  module Printers
+    module Simple # :nodoc: all
+      class << self
+        include TestProf::Logging
+
+        def dump(result)
+          msgs = []
+
+          msgs <<
+            <<~MSG
+              Factories usage
+
+               total      top-level             name
+            MSG
+
+          result.stats.each do |stat|
+            msgs << format("%6d    %11d  %15s", stat[:total], stat[:top_level], stat[:name])
+          end
+
+          log :info, msgs.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/factory_prof.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "test_prof/factory_prof/factory_girl_patch"
+require "test_prof/factory_prof/printers/simple"
+require "test_prof/factory_prof/printers/flamegraph"
+
+module TestProf
+  # FactoryProf collects "factory stacks" that can be used to build
+  # flamegraphs or detect most popular factories
+  module FactoryProf
+    # FactoryProf configuration
+    class Configuration
+      attr_accessor :mode
+
+      def initialize
+        @mode = ENV['FPROF'] == 'flamegraph' ? :flamegraph : :simple
+      end
+
+      # Whether we want to generate flamegraphs
+      def flamegraph?
+        @mode == :flamegraph
+      end
+    end
+
+    class Result # :nodoc:
+      attr_reader :stacks, :raw_stats
+
+      def initialize(stacks, raw_stats)
+        @stacks = stacks
+        @raw_stats = raw_stats
+      end
+
+      # Returns sorted stats
+      def stats
+        return @stats if instance_variable_defined?(:@stats)
+
+        @stats = @raw_stats.values
+                           .sort_by { |el| -el[:total] }
+      end
+
+      def total
+        return @total if instance_variable_defined?(:@total)
+        @total = @raw_stats.values.sum { |v| v[:total] }
+      end
+
+      private
+
+      def sorted_stats(key)
+        @raw_stats.values
+                  .map { |el| [el[:name], el[key]] }
+                  .sort_by { |el| -el[1] }
+      end
+    end
+
+    class << self
+      include TestProf::Logging
+
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
+      # Patch factory lib, init vars
+      def init
+        @running = false
+
+        log :info, "FactoryProf enabled (#{config.mode} mode)"
+
+        # Monkey-patch FactoryGirl
+        ::FactoryGirl::FactoryRunner.prepend(FactoryGirlPatch) if
+          defined?(::FactoryGirl)
+      end
+
+      # Inits FactoryProf and setups at exit hook,
+      # then runs
+      def run
+        init
+
+        printer = config.flamegraph? ? Printers::Flamegraph : Printers::Simple
+
+        at_exit { printer.dump(result) }
+
+        start
+      end
+
+      def start
+        reset!
+        @running = true
+      end
+
+      def stop
+        @running = false
+      end
+
+      def result
+        Result.new(@stacks, @stats)
+      end
+
+      def track(strategy, factory)
+        return yield if !running? || (strategy != :create)
+        begin
+          @depth += 1
+          @current_stack << factory if config.flamegraph?
+          @stats[factory][:total] += 1
+          @stats[factory][:top_level] += 1 if @depth == 1
+          yield
+        ensure
+          @depth -= 1
+          flush_stack if @depth.zero?
+        end
+      end
+
+      private
+
+      def reset!
+        @stacks = [] if config.flamegraph?
+        @depth = 0
+        @stats = Hash.new { |h, k| h[k] = { name: k, total: 0, top_level: 0 } }
+        flush_stack
+      end
+
+      def flush_stack
+        return unless config.flamegraph?
+        @stacks << @current_stack unless @current_stack.nil? || @current_stack.empty?
+        @current_stack = []
+      end
+
+      def running?
+        @running == true
+      end
+    end
+  end
+end
+
+TestProf.activate('FPROF') do
+  TestProf::FactoryProf.run
+end

data/lib/test_prof/logging.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TestProf
+  # Helper for output printing
+  module Logging
+    COLORS = {
+      info: "\e[34m", # blue
+      error: "\e[31m", # red
+    }.freeze
+
+    def log(level, msg)
+      TestProf.config.output.puts(build_log_msg(level, msg))
+    end
+
+    def build_log_msg(level, msg)
+      colorize(level, "[TEST PROF #{level.to_s.upcase}] #{msg}")
+    end
+
+    def colorize(level, msg)
+      return msg unless TestProf.config.color?
+
+      "#{COLORS[level]}#{msg}\e[0m"
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "test_prof/any_fixture"
+
+RSpec.shared_context "any_fixture:clean", with_clean_fixture: true do
+  before do
+    raise("Cannot use clean context without a transaction!") unless
+      open_transaction?
+
+    TestProf::AnyFixture.clean
+  end
+
+  def open_transaction?
+    pool = ActiveRecord::Base.connection_pool
+    pool.active_connection? && pool.connection.open_transactions.positive?
+  end
+end
+
+RSpec.configure do |config|
+  config.after(:suite) { TestProf::AnyFixture.reset }
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TestProf
+  # Helper to wrap the whole example group into a transaction
+  module BeforeAll
+    def before_all(&block)
+      raise ArgumentError, "Block is required!" unless block_given?
+
+      before(:all) do
+        ActiveRecord::Base.connection.begin_transaction(joinable: false)
+        instance_eval(&block)
+      end
+
+      after(:all) do
+        ActiveRecord::Base.connection.rollback_transaction
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.extend TestProf::BeforeAll
+end