test-prof 0.1.0.beta1

data/guides/rubocop.md

@@ -0,0 +1,48 @@
+# 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/guides/ruby_prof.md

@@ -0,0 +1,61 @@
+# Profiling with RubyProf
+
+Easily integrate the power of [ruby-prof](https://github.com/ruby-prof/ruby-prof) into your test suite.
+
+## Instructions
+
+Install `ruby-prof` gem (>= 0.16):
+
+```ruby
+# Gemfile
+group :development, :test do
+  gem 'ruby-prof', require: false
+end
+```
+
+RubyProf profiler has two modes: _global_ and _per-example_.
+
+You can activate the global profiling using the environment variable `TEST_RUBY_PROF`:
+
+```sh
+TEST_RUBY_PROF=1 bundle exec rake test
+
+# or for RSpec
+TEST_RUBY_PROF=1 rspec ...
+```
+
+Or in your code:
+
+```ruby
+TestProf::RubyProf.run
+```
+
+TestProf provides a built-in shared context for RSpec to profile examples individually:
+
+```ruby
+it "is doing heavy stuff", :rprof do
+  ...
+end
+```
+
+### Configuration
+
+The most useful configuration option is `printer` – it allows you to specify a RubyProf [printer](https://github.com/ruby-prof/ruby-prof#printers).
+
+You can specify a printer through environment variable `TEST_RUBY_PROF_PRINTER`:
+
+```sh
+TEST_RUBY_PROF_PRINTER=flat bundle exec rake test
+```
+
+Or in your code:
+
+```ruby
+TestProf::RubyProf.configure do |config|
+  config.printer = :flat
+end
+```
+
+By default, we use `CallStackPrinter`.
+
+See [ruby_prof.rb](https://github.com/palkan/test-prof/tree/master/lib/test_prof/ruby_prof.rb) for all available configuration options and their usage.

data/guides/stack_prof.md

@@ -0,0 +1,43 @@
+# Profiling with StackProf
+
+[StackProf](https://github.com/tmm1/stackprof) is a sampling call-stack profiler for ruby.
+
+## Instructions
+
+Install 'stackprof' gem (>= 0.2.7):
+
+```ruby
+# Gemfile
+group :development, :test do
+  gem 'stackprof', require: false
+end
+```
+
+StackProf profiler has 2 modes: _global_ and _per-example_.
+
+You can activate the global profiling using the environment variable `TEST_STACK_PROF`:
+
+```sh
+TEST_STACK_PROF=1 bundle exec rake test
+
+# or for RSpec
+TEST_STACK_PROF=1 rspec ...
+```
+
+Or in your code:
+
+```ruby
+TestProf::StackProf.run
+```
+
+TestProf provides a built-in shared context for RSpec to profile examples individually:
+
+```ruby
+it "is doing heavy stuff", :sprof do
+  ...
+end
+```
+
+### Configuration
+
+See [stack_prof.rb](https://github.com/palkan/test-prof/tree/master/lib/test_prof/stack_prof.rb) for all available configuration options and their usage.

data/lib/test-prof.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "test_prof"

data/lib/test_prof/any_fixture.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module TestProf
+  # Make DB fixtures from blocks.
+  module AnyFixture
+    INSERT_RXP = /^INSERT INTO ([\S]+)/
+
+    class Cache # :nodoc:
+      attr_reader :store
+
+      delegate :clear, to: :store
+
+      def initialize
+        @store = {}
+      end
+
+      def fetch(key)
+        return store[key] if store.key?(key)
+        return unless block_given?
+        store[key] = yield
+      end
+    end
+
+    class << self
+      # Register a block of code as a fixture,
+      # returns the result of the block execution
+      def register(id)
+        cache.fetch(id) do
+          ActiveSupport::Notifications.subscribed(method(:subscriber), "sql.active_record") do
+            yield
+          end
+        end
+      end
+
+      # Clean all affected tables (but do not reset cache)
+      def clean
+        tables_cache.keys.each do |table|
+          ActiveRecord::Base.connection.execute %(
+            DELETE FROM #{table}
+          )
+        end
+      end
+
+      # Reset all information and clean tables
+      def reset
+        clean
+        tables_cache.clear
+        cache.clear
+      end
+
+      def subscriber(_event, _start, _finish, _id, data)
+        matches = data.fetch(:sql).match(INSERT_RXP)
+        tables_cache[matches[1]] = true if matches
+      end
+
+      private
+
+      def cache
+        @cache ||= Cache.new
+      end
+
+      def tables_cache
+        @tables_cache ||= {}
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module TestProf::EventProf::CustomEvents
+  module FactoryCreate # :nodoc: all
+    module RunnerPatch
+      def run(strategy = @strategy)
+        return super unless strategy == :create
+        FactoryCreate.track(@name) do
+          super
+        end
+      end
+    end
+
+    class << self
+      def setup!
+        @depth = 0
+        FactoryGirl::FactoryRunner.prepend RunnerPatch
+      end
+
+      def track(factory)
+        @depth += 1
+        res = nil
+        begin
+          res =
+            if @depth == 1
+              ActiveSupport::Notifications.instrument(
+                'factory.create',
+                name: factory
+              ) { yield }
+            else
+              yield
+            end
+        ensure
+          @depth -= 1
+        end
+        res
+      end
+    end
+  end
+end
+
+if TestProf.require(
+  'factory_girl',
+  <<~MSG
+    Failed to load FactoryGirl.
+
+    Make sure that "factory_girl" gem is in your Gemfile.
+  MSG
+)
+  TestProf::EventProf::CustomEvents::FactoryCreate.setup!
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module TestProf::EventProf::CustomEvents
+  module SidekiqInline # :nodoc: all
+    module ClientPatch
+      def raw_push(*)
+        return super unless Sidekiq::Testing.inline?
+        SidekiqInline.track { super }
+      end
+    end
+
+    class << self
+      def setup!
+        @depth = 0
+        Sidekiq::Client.prepend ClientPatch
+      end
+
+      def track
+        @depth += 1
+        res = nil
+        begin
+          res =
+            if @depth == 1
+              ActiveSupport::Notifications.instrument(
+                'sidekiq.inline'
+              ) { yield }
+            else
+              yield
+            end
+        ensure
+          @depth -= 1
+        end
+        res
+      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::SidekiqInline.setup!
+end