rspec-activerecord-formatter 1.0.3 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb680f42fdf9b7a605517cf7a577b17a494b0d8125e06616891f5aab77a359b5
-  data.tar.gz: 984a2d0ab39d672bfc42d1cdfd8c6aa73435227a9745b1d672e709818d0f8a26
+  metadata.gz: 3eaf70a87ed79a750607124b849bc8f75325f3cbd8b27c6c6c378008bec7d058
+  data.tar.gz: 339da336745315f324dcac1a71ae2ec9800623b250c1f1cbb3e2bf7f7c1c2461
 SHA512:
-  metadata.gz: 218ab5de04b4b8f01d80cd66b83c4a96dd7ecab0019660db3279ea593e62410c1c6ca58370d811e2b1be208123106c7e1124bf8e7d13cf133f0e0162733a4bb7
-  data.tar.gz: ec002a337aed2d08b180504e36c6d284e920b73f26371b3bf8cdd3ffd5d95ec70f751e8d22b10620c0b4291cdc705a2ef936b8973df5a23f2ed8522c2e89a44c
+  metadata.gz: 671d5e6dc1b7a4abf41c831a26fe6d7f0e599babfb95bcdca2cc5e08e9704bfef855fc9327a349bbd5f5ad9e81032f529ca50d8cb09344589c35bd04c63a22ca
+  data.tar.gz: 27dd9d446ebf122ce2ef1fb442440a36965557e99f34e4fe730bcaa18607470b23dbb24dc0e0a8405961ea582bc9920817e9ac193d1dff33b19690a32b5f4cd1

data/.gitignore

@@ -1,3 +1,4 @@
 .DS_Store
 Gemfile.lock
 coverage
+*.gem

data/README.md

@@ -17,7 +17,7 @@ Installation
 Normal bundle stuff. You'll almost certainly need to add this gem to your
 bundle at least temporarily, since you'll be running rspec using bundler.
 
-    gem 'rspec-activerecord-formatter'
+    gem 'rspec-activerecord-formatter', require: false
 
 
 Usage
@@ -25,15 +25,16 @@ Usage
 
 The current answer is to change your `.rspec` initializer to include the following:
 
+    --require rspec-activerecord-formatter
     --require rails_helper
-    --format ActiveRecordFormatter
+    --format ActiveRecordDocumentationFormatter
 
 We have to include the rails_helper so that ActiveRecord is loaded prior to trying to load the
 formatter. That way, we can hook into AR creations.
 
 You can also run the formatter as a one-off option to rspec:
 
-    rspec path/to/example_spec.rb --require rails_helper --format ActiveRecordFormatter
+    rspec path/to/example_spec.rb --require rspec-activerecord-formatter --require rails_helper --format ActiveRecordDocumentationFormatter
 
 Once you set the formatter, you should now see the number of objects created and total queries
 for each of your tests:
@@ -44,12 +45,17 @@ You'll also get a summary at the end of your test run:
 
 ![Test summary.](https://github.com/jmmastey/rspec-activerecord-formatter/raw/master/doc/images/demo_1.png "Test summary.")
 
+If you want less granularity, you can also use the progress formatter:
+
+    --require rspec-activerecord-formatter
+    --require rails_helper
+    --format ActiveRecordProgressFormatter
+
 Next Steps
 ------------
 * The method I was using to count AR objects doesn't work well with DatabaseCleaner when not explicitly wiring the library into `before` blocks.
   I'd like to be able to go back to a method other than scanning for `INSERT INTO` strings.
 * Configuration, especially formatting the output to optionally outdent the counts.
-* Add a `--profile`-like behavior to output the most offending tests.
 * The current dependency versions are a vague guess. They can and should clearly be more lenient.
 * I dunno, tests.
 

data/lib/rspec-activerecord-formatter.rb

@@ -1 +1,6 @@
+require "rspec/activerecord/helpers/collector"
+require "rspec/activerecord/helpers/report"
+require 'rspec/activerecord/base'
+require 'rspec/activerecord/progress_formatter'
+require 'rspec/activerecord/documentation_formatter'
 require 'rspec/activerecord/formatter'

data/lib/rspec/activerecord/base.rb

@@ -0,0 +1,43 @@
+class ActiveRecordFormatterBase
+  attr_reader :colorizer, :summary, :collector
+
+  def initialize(summary, collector)
+    @colorizer  = ::RSpec::Core::Formatters::ConsoleCodes
+    @summary    = summary
+    @collector  = collector
+  end
+
+  def colorized_summary
+    formatted = "\nFinished in #{summary.formatted_duration} " \
+      "(files took #{summary.formatted_load_time} to load)\n" \
+      "#{colorized_expanded_totals}\n"
+
+    unless summary.failed_examples.empty?
+      formatted << summary.colorized_rerun_commands(colorizer) << "\n"
+    end
+
+    formatted
+  end
+
+  private
+
+  def colorized_expanded_totals
+    if summary.failure_count > 0
+      colorizer.wrap(expanded_totals_line, RSpec.configuration.failure_color)
+    elsif summary.pending_count > 0
+      colorizer.wrap(expanded_totals_line, RSpec.configuration.pending_color)
+    else
+      colorizer.wrap(expanded_totals_line, RSpec.configuration.success_color)
+    end
+  end
+
+  def expanded_totals_line
+    summary_text = ::RSpec::Core::Formatters::Helpers.pluralize(summary.example_count, "example")
+    summary_text << ", " << ::RSpec::Core::Formatters::Helpers.pluralize(summary.failure_count, "failure")
+    summary_text << ", #{summary.pending_count} pending" if summary.pending_count > 0
+    summary_text << ", #{collector.total_objects} AR objects"
+    summary_text << ", #{collector.total_queries} AR queries"
+
+    summary_text
+  end
+end

data/lib/rspec/activerecord/documentation_formatter.rb

@@ -0,0 +1,58 @@
+class ActiveRecordDocumentationFormatter < ::RSpec::Core::Formatters::DocumentationFormatter
+  attr_reader :collector, :colorizer, :report
+
+  ::RSpec::Core::Formatters.register self, :start, :dump_summary,
+                                           :example_started, :example_group_started,
+                                           :example_group_finished
+
+  def initialize(output)
+    super
+
+    @colorizer  = ::RSpec::Core::Formatters::ConsoleCodes
+    @collector  = ActiveRecordFormatterHelpers::Collector.new
+    @report     = ActiveRecordFormatterHelpers::Report.new(collector)
+  end
+
+  def start(_start_notification)
+    output.puts "Recording and reporting ActiveRecord select and creation counts."
+    super
+  end
+
+  def example_group_started(example_group)
+    collector.group_started(example_group.group)
+    super
+  end
+
+  def example_group_finished(example_group)
+    collector.group_finished(example_group.group)
+    super
+  end
+
+  def example_started(example)
+    collector.reset_example(example)
+  end
+
+  def dump_summary(summary)
+    base = ActiveRecordFormatterBase.new(summary, collector)
+    output.puts base.colorized_summary
+
+    output.puts "\nOutputting Detailed Profile Data to #{report.report_path}"
+    report.write
+  end
+
+  protected
+
+  def passed_output(example)
+    "#{current_indentation}#{example_counts}" +
+      colorizer.wrap(example.description.strip, :success)
+  end
+
+  def failure_output(example)
+    "#{current_indentation}#{example_counts}" +
+      colorizer.wrap("#{example.description.strip} (FAILED - #{next_failure_index})", :failure)
+  end
+
+  def example_counts(suffix: " ")
+    "(%02d, %02d)#{suffix}" % [collector.objects_count, collector.query_count]
+  end
+end

data/lib/rspec/activerecord/formatter.rb

@@ -1,81 +1 @@
-require_relative "helpers/collector"
-
-class ActiveRecordFormatter < ::RSpec::Core::Formatters::DocumentationFormatter
-  attr_reader :collector, :colorizer, :configuration
-
-  ::RSpec::Core::Formatters.register self, :start, :dump_summary,
-                                           :example_started, :example_passed, :example_failed
-
-  def initialize(output)
-    super
-
-    @colorizer      = ::RSpec::Core::Formatters::ConsoleCodes
-    @collector      = ActiveRecordFormatterHelpers::Collector.new
-  end
-
-  def start(start_notification)
-    output.puts "Recording and reporting ActiveRecord select and creation counts."
-  end
-
-  def example_started(example)
-    collector.reset_example
-  end
-
-  def dump_summary(summary)
-    formatted = "\nFinished in #{summary.formatted_duration} " \
-      "(files took #{summary.formatted_load_time} to load)\n" \
-      "#{colorized_expanded_totals(summary)}\n"
-
-    unless summary.failed_examples.empty?
-      formatted << summary.colorized_rerun_commands(colorizer) << "\n"
-    end
-
-    output.puts formatted
-    output.puts record_type_summaries
-  end
-
-  def record_type_summaries
-    summary = ["", "Summary of Queries"]
-    collector.most_common_query_names.each do |name, count|
-      summary << "%-4s %s" % [count, name]
-    end
-
-    summary.join("\n")
-  end
-
-  protected
-
-  def passed_output(example)
-    "#{current_indentation}#{example_counts}" +
-      colorizer.wrap(example.description.strip, :success)
-  end
-
-  def failure_output(example)
-    "#{current_indentation}#{example_counts}" +
-      colorizer.wrap("#{example.description.strip} (FAILED - #{next_failure_index})", :failure)
-  end
-
-  def example_counts(suffix: " ")
-    "(%02d, %02d)#{suffix}" % [collector.objects_count, collector.query_count]
-  end
-
-  def colorized_expanded_totals(summary)
-    if summary.failure_count > 0
-      colorizer.wrap(expanded_totals_line(summary), RSpec.configuration.failure_color)
-    elsif summary.pending_count > 0
-      colorizer.wrap(expanded_totals_line(summary), RSpec.configuration.pending_color)
-    else
-      colorizer.wrap(expanded_totals_line(summary), RSpec.configuration.success_color)
-    end
-  end
-
-  def expanded_totals_line(summary)
-    summary_text = ::RSpec::Core::Formatters::Helpers.pluralize(summary.example_count, "example")
-    summary_text << ", " << ::RSpec::Core::Formatters::Helpers.pluralize(summary.failure_count, "failure")
-    summary_text << ", #{summary.pending_count} pending" if summary.pending_count > 0
-    summary_text << ", #{collector.total_objects} AR objects"
-    summary_text << ", #{collector.total_queries} AR queries"
-
-    summary_text
-  end
-end
+ActiveRecordFormatter = ActiveRecordDocumentationFormatter

data/lib/rspec/activerecord/helpers/collector.rb

@@ -2,15 +2,21 @@ require 'active_support/notifications'
 
 module ActiveRecordFormatterHelpers
   class Collector
-    attr_reader :query_count, :objects_count, :total_queries, :total_objects, :query_names
+    attr_reader :query_count, :objects_count, :total_queries, :total_objects,
+                :query_names, :active_groups, :group_counts, :groups_encountered
+
     SKIP_QUERIES = ["SELECT tablename FROM pg_tables", "select sum(ct) from (select count(*) ct from"]
 
     def initialize
+      #@unnamed_queries = []
       @query_count    = 0
+      @groups_encountered = 0
       @objects_count  = 0
       @total_queries  = 0
       @total_objects  = 0
       @query_names    = Hash.new(0)
+      @group_counts   = Hash.new(0)
+      @active_groups  = []
 
       ActiveSupport::Notifications.subscribe("sql.active_record", method(:record_query))
     end
@@ -18,33 +24,126 @@ module ActiveRecordFormatterHelpers
     def record_query(*_unused, data)
       return if SKIP_QUERIES.any? { |q| data[:sql].index(q) == 0 }
 
-      @query_count    += 1
-      @total_queries  += 1
-
-      if query_is_an_insert?(data[:sql])
-        @objects_count  += 1
-        @total_objects  += 1
-      end
-
-      name = data[:name] || "Unnamed"
-      @query_names[name] += 1
+      inc_query
+      inc_object if query_is_an_insert?(data[:sql])
+      inc_query_name(data)
     end
 
     def most_common_query_names
-      @query_names.sort_by(&:last).reverse
+      query_names.sort_by(&:last).reverse
+    end
+
+    def most_expensive_groups
+      group_counts.sort_by(&:last).reverse
     end
 
-    def reset_example
+    def reset_example(_)
       @query_count   = 0
       @objects_count = 0
     end
 
+    def group_started(group)
+      @groups_encountered += 1
+
+      return unless group.parent_groups.length > 1
+
+      active_groups.push(group_path(group))
+    end
+
+    def group_finished(group)
+      active_groups.delete(group_path(group))
+    end
+
     protected
 
+    def inc_object
+      @objects_count  += 1
+      @total_objects  += 1
+
+      active_groups.each do |group|
+        @group_counts[group] += 1
+      end
+    end
+
+    def inc_query
+      @query_count    += 1
+      @total_queries  += 1
+    end
+
+    def inc_query_name(data)
+      name = data[:name] || "Unnamed"
+
+      # In older versions of Rails, insert statements are just counted as SQL
+      # queries, which means that all the queries are just bunchedup at the top.
+      # Makes this data pretty useless. So anyway, try to suss out a name for
+      # at least those insertions (which are much more frequent than, say,
+      # updates in a test suite anyway).
+      if data[:name] == "SQL" && query_is_an_insert?(data[:sql])
+        table = data[:sql].scan(/INSERT INTO "(\w+)"/).first.first
+        name = "#{table} Create"
+      elsif query_is_a_full_table_delete?(data[:sql])
+        table = data[:sql].scan(/DELETE FROM "(\w+)"/).first.first
+        name = "Full Delete Table"
+      # TODO: truncate table
+      elsif query_is_transaction_management?(data[:sql])
+        name = "Transaction Management"
+      elsif query_is_schema_detection?(data[:sql])
+        name = "SCHEMA"
+      elsif query_is_trigger_management?(data[:sql])
+        name = "Trigger Management"
+      elsif query_refreshes_materialized_view?(data[:sql])
+        name = "Refresh Materialized View"
+      end
+
+
+      # In older versions of Rails, insert statements are just counted as SQL
+      # queries, which means that all the queries are just bunchedup at the top.
+      # Makes this data pretty useless. So anyway, try to suss out a name for
+      # at least those insertions (which are much more frequent than, say,
+      # updates in a test suite anyway).
+      #if data[:name].nil? && query_is_a_delete?(data[:sql])
+      #  table = data[:sql].scan(/DELETE FROM "(\w+)"/).first.first
+      #  name = "#{table} Delete"
+      #end
+
+      #@unnamed_queries << data if name == "Unnamed"
+
+      query_names[name] += 1
+    end
+
+    def group_path(group)
+      group.parent_groups.reverse.map(&:description).join(' ')
+    end
+
     # TODO: what happens if we try to create many records at once?
     # TODO: are there any false positives we need to worry about? false negatives?
     def query_is_an_insert?(query)
-      query =~ /INSERT INTO/
+      query =~ /^INSERT INTO/
+    end
+
+    def query_is_a_delete?(query)
+      query =~ /^DELETE FROM/
+    end
+
+    def query_is_a_full_table_delete?(query)
+      query =~ /^DELETE FROM [a-z_\."]*;$/i
+    end
+
+    def query_is_transaction_management?(query)
+      query =~ /^(COMMIT|BEGIN|ROLLBACK|SAVEPOINT|RELEASE SAVEPOINT)/
+    end
+
+    def query_is_schema_detection?(query)
+      query =~ /SELECT .* FROM pg_tables/m ||
+        query =~ /SELECT .* FROM information_schema.views/
+    end
+
+    def query_is_trigger_management?(query)
+      query =~ /(DISABLE|ENABLE) TRIGGER ALL/m
+    end
+
+    def query_refreshes_materialized_view?(query)
+      query =~ /REFRESH MATERIALIZED VIEW/m
     end
   end
 end

data/lib/rspec/activerecord/helpers/report.rb

@@ -0,0 +1,45 @@
+module ActiveRecordFormatterHelpers
+  class Report
+    attr_reader :report_path, :default_path, :report_dir, :collector
+
+    def initialize(collector)
+      @collector = collector
+
+      @report_dir   = Rails.root.join("tmp", "profile")
+      @report_path  = report_dir.join(timestamped_filename)
+      @default_path = report_dir.join('ar_most_recent.txt')
+    end
+
+    def write
+      write_file(file_path: report_path)
+      write_file(file_path: default_path)
+    end
+
+    private
+
+    def timestamped_filename
+      Time.now.strftime("ar_%Y_%m_%d_%H_%m_%S.txt")
+    end
+
+    def write_file(file_path:)
+      Dir.mkdir(report_dir) unless File.exists?(report_dir)
+
+      File.open(file_path, "wb") do |f|
+        f.puts "#{collector.total_objects} AR objects, #{collector.total_queries} AR queries"
+        f.puts "#{collector.groups_encountered} example groups executed"
+
+        f.puts ""
+        f.puts "Worst Example Groups by Object Creation"
+        collector.most_expensive_groups.first(50).each do |name, count|
+          f.puts "%-5s %s" % [count, name]
+        end
+
+        f.puts ""
+        f.puts "Most Common Queries"
+        collector.most_common_query_names.first(50).each do |name, count|
+          f.puts "%-5s %s" % [count, name]
+        end
+      end
+    end
+  end
+end

data/lib/rspec/activerecord/progress_formatter.rb

@@ -0,0 +1,44 @@
+require_relative "helpers/collector"
+require_relative "helpers/report"
+
+class ActiveRecordProgressFormatter < ::RSpec::Core::Formatters::ProgressFormatter
+  attr_reader :collector, :colorizer, :report
+
+  ::RSpec::Core::Formatters.register self, :start, :dump_summary,
+                                           :example_started, :example_group_started,
+                                           :example_group_finished
+
+  def initialize(output)
+    super
+
+    @colorizer  = ::RSpec::Core::Formatters::ConsoleCodes
+    @collector  = ActiveRecordFormatterHelpers::Collector.new
+    @report     = ActiveRecordFormatterHelpers::Report.new(collector)
+  end
+
+  def start(_start_notification)
+    output.puts "Recording and reporting ActiveRecord select and creation counts."
+    super
+  end
+
+  def example_group_started(example_group)
+    collector.group_started(example_group.group)
+    super
+  end
+
+  def example_group_finished(example_group)
+    collector.group_finished(example_group.group)
+  end
+
+  def example_started(example)
+    collector.reset_example(example)
+  end
+
+  def dump_summary(summary)
+    base = ActiveRecordFormatterBase.new(summary, collector)
+    output.puts base.colorized_summary
+
+    output.puts "\nOutputting Detailed Profile Data to #{report.report_path}"
+    report.write
+  end
+end

data/rspec-activerecord-formatter.gemspec

@@ -6,7 +6,7 @@ $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
 Gem::Specification.new do |gem|
 
   gem.name    = "rspec-activerecord-formatter"
-  gem.version = "1.0.3"
+  gem.version = "2.1.0"
 
   gem.summary     = "Adds object creations and queries to Rspec output."
   gem.description = "Creates a new formatter for ActiveRecord that can help you diagnose performance issues in RSpec"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-activerecord-formatter
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 2.1.0
 platform: ruby
 authors:
 - Joseph Mastey
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-04-07 00:00:00.000000000 Z
+date: 2020-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -72,8 +72,12 @@ files:
 - doc/images/demo_1.png
 - doc/images/demo_2.png
 - lib/rspec-activerecord-formatter.rb
+- lib/rspec/activerecord/base.rb
+- lib/rspec/activerecord/documentation_formatter.rb
 - lib/rspec/activerecord/formatter.rb
 - lib/rspec/activerecord/helpers/collector.rb
+- lib/rspec/activerecord/helpers/report.rb
+- lib/rspec/activerecord/progress_formatter.rb
 - rspec-activerecord-formatter.gemspec
 - spec/collector_spec.rb
 - spec/formatter_spec.rb
@@ -82,7 +86,7 @@ homepage: http://github.com/jmmastey/rspec-activerecord-formatter
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -97,9 +101,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Adds object creations and queries to Rspec output.
 test_files: []