test-prof 0.1.0.beta1 → 0.1.0.pre5

data/guides/factory_prof.md

@@ -1,85 +0,0 @@
-# FactoryProf
-
-FactoryProf tracks your factories usage statistics, i.e. how often each factory has been used.
-
-Example output:
-
-```sh
-[TEST PROF INFO] Factories usage
-
- total      top-level             name
-
-     8              4             user
-     5              3             post
-```
-
-
-It shows both the total number of the factory runs and the number of _top-level_ runs, i.e. not during another factory invocation (e.g. when using associations.)
-
-**NOTE**: FactoryProf only tracks the usage of `create` strategy.
-
-## Instructions
-
-FactoryProf can only be used with FactoryGirl.
-
-To activate FactoryProf use `FPROF` environment variable:
-
-```sh
-# Simple profiler
-FPROF=1 rspec
-
-# or 
-FPROF=1 bundle exec rake test
-```
-
-## Factory Flamegraph
-
-The most useful feature of FactoryProf is the _FactoryFlame_ report. That's the special interpetation of Brendan Gregg's [flame graphs](http://www.brendangregg.com/flamegraphs.html) which allows you to identify _factory cascades_.
-
-To generate FactoryFlame report set `FPROF` environment variable to `flamegraph`:
-
-```sh
-FPROF=flamegraph rspec
-
-# or 
-FPROF=flamegraph bundle exec rake test
-```
-
-That's how a report looks like:
-
-![](https://s3-us-west-1.amazonaws.com/vladem/test-prof/factory-flame.gif)
-
-How to read this?
-
-Every column represents a _factory stack_ or _cascade_, that is a sequence of recursive `#create` method calls. Consider and example:
-
-```ruby
-factory :comment do
-  answer
-  author
-end
-
-factory :answer do
-  question
-  author
-end
-
-factory :question do
-  author
-end
-
-create(:comment) #=> creates 5 records
-
-# And the corresponding stack is:
-[:comment, :answer, :question, :author, :author, :author]
-```
-
-The wider column the more often this stack appears.
-
-The `root` cell shows the total number of `create` calls.
-
-## Acknowledgements
-
-- Thanks to [Martin Spier](https://github.com/spiermar) for [d3-flame-graph](https://github.com/spiermar/d3-flame-graph)
-
-- Thanks to [Sam Saffron](https://github.com/SamSaffron) for his [flame graphs implementation](https://github.com/SamSaffron/flamegraph).

data/guides/rubocop.md

@@ -1,48 +0,0 @@
-# Custom Rubocop Cops
-
-TestProf comes with the [Rubocop](https://github.com/bbatsov/rubocop) cops that help you write more performant tests.
-
-To enable them:
-
-- Require `test_prof/rubocop` in your Rubocop configuration:
-
-```yml
-# .rubocop.yml
-require:
- - 'test_prof/rubocop'
-```
-
-- Enable cops:
-
-```yml
-RSpec/AggregateFailures:
-  Enabled: true
-  Include:
-    - 'spec/**/*.rb'
-```
-
-## Rspec/AggregateFailures
-
-This cop encourages you to use one of the greatest features of the recent RSpec – aggregating failures within an example.
-
-Instead of writing one example per assertion, you can group _independent_ assertions together, thus running all setup hooks only once. That can dramatically increase your performance (by reducing the total number of examples).
-
-Consider an example:
-
-```ruby
-# bad
-it { is_expected.to be_success }
-it { is_expected.to have_header('X-TOTAL-PAGES', 10) }
-it { is_expected.to have_header('X-NEXT-PAGE', 2) }
-
-# good
-it "returns the second page", :aggregate_failures do
-  is_expected.to be_success
-  is_expected.to have_header('X-TOTAL-PAGES', 10)
-  is_expected.to have_header('X-NEXT-PAGE', 2)
-end
-```
-
-This cop supports auto-correct feature, so you can automatically refactor you legacy tests!
-
-**NOTE**: auto-correction may break your tests (especially the ones using block-matchers, such as `change`).

data/lib/test_prof/cops/rspec/aggregate_failures.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubocop'
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Rejects and auto-corrects the usage of one-liners examples in favour of
-      # :aggregate_failures feature.
-      #
-      # Example:
-      #
-      #  # bad
-      #  it { is_expected.to be_success }
-      #  it { is_expected.to have_header('X-TOTAL-PAGES', 10) }
-      #  it { is_expected.to have_header('X-NEXT-PAGE', 2) }
-      #
-      #  # good
-      #  it "returns the second page", :aggregate_failures do
-      #    is_expected.to be_success
-      #    is_expected.to have_header('X-TOTAL-PAGES', 10)
-      #    is_expected.to have_header('X-NEXT-PAGE', 2)
-      #  end
-      #
-      class AggregateFailures < RuboCop::Cop::Cop
-        # From https://github.com/backus/rubocop-rspec/blob/master/lib/rubocop/rspec/language.rb
-        GROUP_BLOCKS = %i[
-          describe context feature example_group
-          xdescribe xcontext xfeature
-          fdescribe fcontext ffeature
-        ].freeze
-
-        EXAMPLE_BLOCKS = %i[
-          it specify example scenario its
-          fit fspecify fexample fscenario focus
-          xit xspecify xexample xscenario ski
-          pending
-        ].freeze
-
-        def on_block(node)
-          method, _args, body = *node
-          return unless body&.begin_type?
-
-          _receiver, method_name, _object = *method
-          return unless GROUP_BLOCKS.include?(method_name)
-
-          return if check_node(body)
-
-          add_offense(
-            node,
-            :expression,
-            'Use :aggregate_failures instead of several one-liners.'
-          )
-        end
-
-        def autocorrect(node)
-          _method, _args, body = *node
-          iter = body.children.each
-
-          first_example = loop do
-            child = iter.next
-            break child if oneliner?(child)
-          end
-
-          base_indent = " " * first_example.source_range.column
-
-          replacements = [
-            header_from(first_example),
-            body_from(first_example, base_indent)
-          ]
-
-          last_example = nil
-
-          loop do
-            child = iter.next
-            break unless oneliner?(child)
-            last_example = child
-            replacements << body_from(child, base_indent)
-          end
-
-          replacements << "#{base_indent}end"
-
-          range = first_example.source_range.begin.join(
-            last_example.source_range.end
-          )
-
-          replacement = replacements.join("\n")
-
-          lambda do |corrector|
-            corrector.replace(range, replacement)
-          end
-        end
-
-        private
-
-        def check_node(node)
-          offenders = 0
-
-          node.children.each do |child|
-            if oneliner?(child)
-              offenders += 1
-            elsif example_node?(child)
-              break if offenders > 1
-              offenders = 0
-            end
-          end
-
-          offenders < 2
-        end
-
-        def oneliner?(node)
-          node&.block_type? &&
-            (node.source.lines.size == 1) &&
-            example_node?(node)
-        end
-
-        def example_node?(node)
-          method, _args, _body = *node
-          _receiver, method_name, _object = *method
-          EXAMPLE_BLOCKS.include?(method_name)
-        end
-
-        def header_from(node)
-          method, _args, _body = *node
-          _receiver, method_name, _object = *method
-          %(#{method_name} "works", :aggregate_failures do)
-        end
-
-        def body_from(node, base_indent = '')
-          _method, _args, body = *node
-          "#{base_indent}#{indent}#{body.source}"
-        end
-
-        def indent
-          @indent ||= " " * (config.for_cop('IndentationWidth')['Width'] || 2)
-        end
-      end
-    end
-  end
-end

data/lib/test_prof/factory_prof/factory_girl_patch.rb

@@ -1,12 +0,0 @@
-# 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

@@ -1,71 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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

@@ -1,140 +0,0 @@
-# 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/rubocop.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "test_prof/cops/rspec/aggregate_failures"