rspec-activerecord-formatter 1.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 573d9da6bd2d49e858ad2598ecf931c7b9909cc4d53881ed84d27b9e071310c5
-  data.tar.gz: a4f40473db9a50e226ba87b5512b031a1adacf5694f1872ef1571763e997f212
+  metadata.gz: c54759e485d19a1a06d151b7f3a0bb3286cdcbb7085d3a51b9552ffed37ea6f8
+  data.tar.gz: aeaf1ecc3bcc1253b2f6998f2b4a36eba27712e9168b3d3f793753173d21ee34
 SHA512:
-  metadata.gz: 87e83e43deaad1f964e3cc88264ab51779a0362c789f18a5ea3d33d1116059866f7f3df0c8946f936462215b94a8f4440bafb1f11143bf5a7d5a2f964a62f433
-  data.tar.gz: '068fbce81ae37fe58c1e0d97d61f4024cab3cd233618f870d8e4b842d25291810872504dc53c21e702379a92a4aca472dde66fbdb7869a7d57a6ef1524dac255'
+  metadata.gz: 8b01f60872f2818c43ccdb627115f0ac88e62fbeece79436ec24ad1a88beb17f9dc5a241aabc98e8c591a21735107fa82ce00d51262d768ae0d2327840c526e2
+  data.tar.gz: 06cded1f82ba0e87f15b70fe126057e86c96a477a59b163d6ec4bd0503483b8d7e36843a23debf1e2f12279d7ff8b8dfcb8870180fab241dc35dd473e4edff69

data/.gitignore

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

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## [Unreleased]
+
+## [2.1.1] - 2020-11-07
+- Pin dependencies a bit more closely.
+
+## [2.1.0] - 2020-11-07
+
+- Added better detection for query types. Specifically, it's easier now to see
+  how `database_cleaner` impacts your total queries.
+- Adding a changelog, apparently.
+

data/README.md

@@ -27,14 +27,14 @@ The current answer is to change your `.rspec` initializer to include the followi
 
     --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 rspec-activerecord-formatter --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:
@@ -45,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,86 +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
-    write_profile_summary
-  end
-
-  def write_profile_summary
-    output_report_filename = Time.now.strftime("rspec_activerecord_result_%Y_%m_%d_%H_%m_%S.txt")
-    output_report_path = Rails.root.join("tmp", output_report_filename)
-
-    puts "\nOutputting Detailed Profile Data to #{output_report_path}"
-    File.open(output_report_path, "wb") do |f|
-      f.puts "#{collector.total_objects} AR objects, #{collector.total_queries} AR queries\n"
-      f.puts "Query Summary"
-      collector.most_common_query_names.each do |name, count|
-        f.puts "%-4s %s" % [count, name]
-      end
-    end
-  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.1.0"
+  gem.version = "2.1.1"
 
   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"
@@ -25,9 +25,9 @@ Gem::Specification.new do |gem|
 
   gem.require_paths = %w[ext lib].select { |dir| File.directory?(dir) }
 
-  # TODO: these are almost certainly too restrictive.
-  gem.add_dependency "activesupport", ">= 4.0"
+  # TODO: these are almost certainly too restrictive looking backward
+  gem.add_dependency "activesupport", ">= 4.0", "< 7.0"
   gem.add_dependency "rspec", "~> 3.4"
 
-  gem.add_development_dependency "coveralls"
+  gem.add_development_dependency "coveralls", "~> 0.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-activerecord-formatter
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Joseph Mastey
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-06-20 00:00:00.000000000 Z
+date: 2020-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -17,6 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +27,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -42,22 +48,23 @@ dependencies:
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
 description: Creates a new formatter for ActiveRecord that can help you diagnose performance
   issues in RSpec
 email: jmmastey@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - README.md
 files:
@@ -65,6 +72,7 @@ files:
 - ".rspec"
 - ".simplecov"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - MIT-LICENSE
@@ -72,8 +80,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 +94,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 +109,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: []