ar-query-matchers 0.7.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e73f1af783ac0aea8a1342b20e01d139106e29c2c4048bf3d30086a13675f204
-  data.tar.gz: 64b309608ae8f52ba8d7a998ea0e7658eebb2ee7d11122d8e1c0934f042131b6
+  metadata.gz: 85641d6041fd4ef3611a70e0f3b5481e9e4d80d23b1ee0a229e5006831367464
+  data.tar.gz: c27f7061b4b22ff584c90a5d4122f2c71b4e5a452f59c432f215fdbf45b01be1
 SHA512:
-  metadata.gz: 13b5fe44e89c7e0df944882d4d15dac2ff72b8fe3a679591c46b15015587159246c4e2344d2e604b6a31a0ee6dc5a450eacd85ef638d90d578f1b4073fca2f58
-  data.tar.gz: 61d48528375466023a71bf17ad2e453ec62ce5520f43200f88de94ff2f116522be3694fe2c0116f83093fa5f1087cf4774471143e63deb8f465dd03173bda8cd
+  metadata.gz: 0aa94f77507d3bd00e0ca8b982a665df41ececebc657298241271c2e9d7e15a42e84a387b843537f63711e520b56c5b6c37c1b365e9e73930903269716b7158d
+  data.tar.gz: 3605475400e443fb20782d5f651aed89d359ff244c2d8df82d9b02989d957162aa366d45a3cf44ae9cce6afffc29ee46c10a9e0e9024958bbdf150e2c2c56a78

data/CHANGELOG.md

@@ -6,6 +6,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.0] - 2022-01-27
+### Added
+- Changed the implementation of ArQueryMatchers::Queries::TableName to calculate distance of class name to table name to determine which class name is most likely. This changes how tables in `only_load_at_most_models` are calculated.
+
 ## [0.7.0] - 2022-01-27
 ### Added
 - A new matcher, `only_load_at_most_models`, will do a less-than-or-equal-to (<=) check on model counts. This is a method that makes tests less noisy as performance gets better.

data/README.md

@@ -16,7 +16,7 @@ If you'd like to pick that up, please have a look at: https://github.com/Gusto/a
 Include it in your Gemfile:
 ```ruby
 group :test do
-  gem 'ar-query-matchers', '~> 0.2.0', require: false
+  gem 'ar-query-matchers', '~> 0.7.0', require: false
 end
 ```
 
@@ -40,9 +40,10 @@ This gem defines a few categories of matchers:
 - **Update**: Which models are updated during a block
 
 Each matcher category includes 3 assertions, for example, for the Load category, you could use the following assertions:
-- **only_load_models**: Strict assertion, not other query is allowed.
-- **not_load_models**: No models are allowed to be loaded.
-- **load_models**: Inclusion, other models are allowed to be loaded if not specified in the assertion.
+- **only_load_models**: Strict assertion of both models loaded and query counts. No other query is allowed.
+- **only_load_at_most_models**: Strict assertion of models loaded, with an upper bound on the number of queries allowed against each.
+- **not_load_any_models**: No models are allowed to be loaded.
+- **load_models**: Inclusion. Other models are allowed to be loaded if not specified in the assertion.
 
 
 **For example:** 
@@ -58,9 +59,20 @@ expect { some_code() }.to only_load_models(
 )
 ```
 
+The following spec will pass only if there are 4 or less SQL SELECTs that
+load User records (and 1 or less for both Address and Payroll respectively) _and_ no other models
+perform any SELECT queries.
+```ruby
+expect { some_code() }.to only_load_at_most_models(
+  'User' => 4,
+  'Address' => 1,
+  'Payroll' => 1,
+)
+```
+
 The following spec will pass only if there are no select queries.
 ```ruby
-expect { some_code() }.to not_load_models
+expect { some_code() }.to not_load_any_models
 ```
 
 The following spec will pass only if there are exactly 4 SQL SELECTs that

data/lib/ar_query_matchers/queries/create_counter.rb

@@ -17,7 +17,7 @@ module ArQueryMatchers
       class CreateQueryFilter < QueryFilter
         # Matches unnamed SQL operations like the following:
         # "INSERT INTO `company_approval_details` ..."
-        TABLE_NAME_SQL_PATTERN = /INSERT INTO [`"](?<table_name>[^`"]+)[`"]/.freeze
+        TABLE_NAME_SQL_PATTERN = /INSERT INTO [`"](?<table_name>[^`"]+)[`"]/
 
         def filter_map(_name, sql)
           # for inserts, name is always 'SQL', we have to rely on pattern matching the query string.

data/lib/ar_query_matchers/queries/field_counter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative './query_counter'
+require_relative './field_name'
+require_relative './query_filter'
+
+module ArQueryMatchers
+  module Queries
+    # A specialized QueryCounter for "any action that involves field IDs".
+    # For more information, see the QueryCounter class.
+    class FieldCounter
+      def self.instrument(&block)
+        QueryCounter.new(FieldCounterFilter.new).instrument(&block)
+      end
+
+      # Filters queries for counting purposes
+      class FieldCounterFilter < Queries::QueryFilter
+        # We need to look for a few things:
+        # Anything with ` {field} = {value}` (this could be a select, update, delete)
+        MODEL_FIELDS_PATTERN = /\.`(?<field_name>\w+)` = (?<field_value>[\w"`]+)/
+
+        # Anything with ` {field} IN ({value})` (this could be a select, update, delete)
+        MODEL_FIELDS_IN_PATTERN = /\.`(?<field_name>\w+)` IN \((?<field_value>[\w"`]+)\)/
+
+        # Anything with `, field,` in an INSERT (we need to check the values)
+        MODEL_INSERT_PATTERN = /INSERT INTO (?<table_name>[^`"]+) ... VALUES .../
+
+        def cleanup(value)
+          cleaned_value = value.gsub '`', ''
+
+          # If this is an integer, we'll cast it automatically
+          cleaned_value = value.to_i if cleaned_value == value
+
+          cleaned_value
+        end
+
+        def filter_map(_name, sql)
+          # We need to look for a few things:
+          #   - Anything with ` {field} = ` (this could be a select, update, delete)
+          #   - Anything with `, field,` in an INSERT (we need to check the values)
+          select_field_query = sql.match(MODEL_FIELDS_PATTERN)
+          # debugger if sql.match(/INSERT/)
+          # TODO: MODEL_FIELDS_IN_PATTERN and MODEL_INSERT_PATTERN need to be handled
+
+          FieldName.new(select_field_query[:field_name], cleanup(select_field_query[:field_value])) if select_field_query
+        end
+      end
+    end
+  end
+end

data/lib/ar_query_matchers/queries/field_name.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ArQueryMatchers
+  module Queries
+    # An instance of this class is one of the values that could be returned from the QueryFilter#filter_map.
+    # it accepts a name of an ActiveRecord model, for example: 'Company'.
+    class FieldName
+      attr_reader(:model_name, :model_value)
+
+      def initialize(model_name, model_value)
+        @model_name = model_name
+        @model_value = model_value
+      end
+    end
+  end
+end

data/lib/ar_query_matchers/queries/load_counter.rb

@@ -17,17 +17,17 @@ module ArQueryMatchers
       class LoadQueryFilter < Queries::QueryFilter
         # Matches named SQL operations like the following:
         # 'User Load'
-        MODEL_LOAD_PATTERN = /\A(?<model_name>[\w:]+) (Load|Exists)\Z/.freeze
+        MODEL_LOAD_PATTERN = /\A(?<field_name>[\w:]+)/
 
         # Matches unnamed SQL operations like the following:
         # "SELECT COUNT(*) FROM `users` ..."
-        MODEL_SQL_PATTERN = /SELECT (?:(?!SELECT).)* FROM [`"](?<table_name>[^`"]+)[`"]/.freeze
+        MODEL_SQL_PATTERN = /SELECT (?:(?!SELECT).)* FROM [`"](?<table_name>[^`"]+)[`"]/
 
         def filter_map(name, sql)
           # First check for a `SELECT * FROM` query that ActiveRecord has
           # helpfully named for us in the payload
           match = name.match(MODEL_LOAD_PATTERN)
-          return ModelName.new(match[:model_name]) if match
+          return ModelName.new(match[:model_name]) if match&.names&.include? :model_name
 
           # Fall back to pattern-matching on the table name in a COUNT and looking
           # up the table name from ActiveRecord's loaded descendants.

data/lib/ar_query_matchers/queries/query_counter.rb

@@ -44,6 +44,14 @@ module ArQueryMatchers
           Hash[*queries.reduce({}) { |acc, (model_name, data)| acc.update model_name => data[:count] }.sort_by(&:first).flatten]
         end
 
+        def query_values
+          result = {}
+          queries.each do |model_name, data|
+            result[model_name] = data[:values]
+          end
+          result
+        end
+
         # @return [Hash] of line in the source code to its frequency
         def query_lines_by_frequency
           queries.reduce({}) do |lines, (model_name, data)|
@@ -62,7 +70,7 @@ module ArQueryMatchers
       # @param [block] block to instrument
       # @return [QueryStats] stats about all the SQL queries executed during the block
       def instrument(&block)
-        queries = Hash.new { |h, k| h[k] = { count: 0, lines: [], time: BigDecimal(0) } }
+        queries = Hash.new { |h, k| h[k] = { count: 0, lines: [], values: [], time: BigDecimal(0) } }
         ActiveSupport::Notifications.subscribed(to_proc(queries), 'sql.active_record', &block)
         QueryStats.new(queries)
       end
@@ -71,9 +79,18 @@ module ArQueryMatchers
 
       # The 'marginalia' gem adds a line from the backtrace to the SQL query in
       # the form of a comment.
-      MARGINALIA_SQL_COMMENT_PATTERN = %r{/*line:(?<line>.*)'*/}.freeze
+      MARGINALIA_SQL_COMMENT_PATTERN = %r{/*line:(?<line>.*)'*/}
       private_constant :MARGINALIA_SQL_COMMENT_PATTERN
 
+      def add_to_query(queries, payload, model_obj, finish, start)
+        model_name = model_obj&.model_name
+        comment = payload[:sql].match(MARGINALIA_SQL_COMMENT_PATTERN)
+        queries[model_name][:lines] << comment[:line] if comment
+        queries[model_name][:count] += 1
+        queries[model_name][:values].append(model_obj&.model_value) if model_obj.respond_to?(:model_value) && !queries[model_name][:values].include?(model_obj&.model_value)
+        queries[model_name][:time] += (finish - start).round(6) # Round to microseconds
+      end
+
       def to_proc(queries)
         lambda do |_name, start, finish, _message_id, payload|
           return if payload[:cached]
@@ -81,14 +98,10 @@ module ArQueryMatchers
           # Given a `sql.active_record` event, figure out which model is being
           # accessed. Some of the simpler queries have a :name key that makes this
           # really easy. Others require parsing the SQL by hand.
-          model_name = @query_filter.filter_map(payload[:name] || '', payload[:sql] || '')&.model_name
+          model_obj = @query_filter.filter_map(payload[:name] || '', payload[:sql] || '')
+          model_name = model_obj&.model_name
 
-          if model_name
-            comment = payload[:sql].match(MARGINALIA_SQL_COMMENT_PATTERN)
-            queries[model_name][:lines] << comment[:line] if comment
-            queries[model_name][:count] += 1
-            queries[model_name][:time] += (finish - start).round(6) # Round to microseconds
-          end
+          add_to_query(queries, payload, model_obj, finish, start) if model_name
         end
       end
     end

data/lib/ar_query_matchers/queries/table_name.rb

@@ -31,9 +31,9 @@ module ArQueryMatchers
         # { 'users' => [User, AtoUser],
         #   'employees => [Employee, PandaFlows::StateFields] }
 
-        # Of all the models that share the same table name sort them by their
-        # relative ancestry and pick the one that all the rest inherit from
-        tables[table_name].min_by { |a, b| a.ancestors.include?(b) }
+        # Pick the class with the shortest distance to the table name
+        ideal_class_name = table_name.classify
+        tables[table_name].min_by { |a| DidYouMean::Levenshtein.distance(ideal_class_name, a.to_s) }
       end
     end
   end

data/lib/ar_query_matchers/queries/update_counter.rb

@@ -17,7 +17,7 @@ module ArQueryMatchers
       class UpdateQueryFilter < QueryFilter
         # Matches unnamed SQL operations like the following:
         # "UPDATE `bank_account_verifications` ..."
-        TABLE_NAME_SQL_PATTERN = /UPDATE [`"](?<table_name>[^`"]+)[`"]/.freeze
+        TABLE_NAME_SQL_PATTERN = /UPDATE [`"](?<table_name>[^`"]+)[`"]/
 
         def filter_map(_name, sql)
           # for updates, name is always 'SQL', we have to rely on pattern matching on the query string instead.

data/lib/ar_query_matchers.rb

@@ -3,6 +3,7 @@
 require 'ar_query_matchers/queries/create_counter'
 require 'ar_query_matchers/queries/load_counter'
 require 'ar_query_matchers/queries/update_counter'
+require 'ar_query_matchers/queries/field_counter'
 require 'bigdecimal'
 
 module ArQueryMatchers
@@ -225,6 +226,86 @@ module ArQueryMatchers
       end
     end
 
+    class FieldModels
+      # The following will succeed:
+      #
+      #    expect {
+      #       WcRiskClass.last.update_attributes(id: 9999)
+      #       WcRiskClass.last.update_attributes(id: 1234)
+      #    }.to query_by_field(
+      #       'id' => [9999, 1234],
+      #    )
+      #
+      RSpec::Matchers.define(:query_by_field) do |expected = {}|
+        include MatcherConfiguration
+        include MatcherErrors
+
+        # Convert the map of expected values to a Hash of all arrays
+        expected = expected.transform_values { |v| v.is_a(Array) ? v : [v] }
+
+        match do |block|
+          @query_stats = Queries::FieldCounter.instrument(&block)
+          expected == @query_stats.query_values
+        end
+
+        def failure_text
+          expectation_failed_message('query_by', show_values: true)
+        end
+      end
+
+      # The following will succeed:
+      #
+      #    expect {
+      #       WcRiskClass.last.update_attributes(id: 9999)
+      #       WcRiskClass.last.update_attributes(id: 1234)
+      #    }.to query_by_field_at_least(
+      #       'id' => 9999,
+      #    )
+      #
+      RSpec::Matchers.define(:query_by_field_at_least) do |expected = {}|
+        include MatcherConfiguration
+        include MatcherErrors
+
+        # Convert the map of expected values to a Hash of all arrays
+        expected = expected.transform_values { |v| v.is_a?(Array) ? v : [v] }
+
+        match do |block|
+          @query_stats = Queries::FieldCounter.instrument(&block)
+          expected == @query_stats.query_values.select { |k, _| expected.keys.include?(k) }
+        end
+
+        def failure_text
+          expectation_failed_message('query_by', show_values: true, subset: true)
+        end
+      end
+
+      # The following will succeed:
+      #
+      #    expect {
+      #       WcRiskClass.last.update_attributes(id: 9999)
+      #       WcRiskClass.last.update_attributes(id: 1234)
+      #    }.to query_by_field_at_least_ignore_notfound(
+      #       'id' => 6666,
+      #    )
+      #
+      RSpec::Matchers.define(:query_by_field_at_least_ignore_notfound) do |expected = {}|
+        include MatcherConfiguration
+        include MatcherErrors
+
+        # Convert the map of expected values to a Hash of all arrays
+        expected = expected.transform_values { |v| v.is_a?(Array) ? v : [v] }
+
+        match do |block|
+          @query_stats = Queries::FieldCounter.instrument(&block)
+          expected.select { |k, _| @query_stats.query_values.keys.include?(k) } == @query_stats.query_values.select { |k, _| expected.keys.include?(k) }
+        end
+
+        def failure_text
+          expectation_failed_message('query_by', show_values: true, subset: true, ignore_missing: true)
+        end
+      end
+    end
+
     # Shared methods that are included in the matchers.
     # They configure it and ensure we get consistent and human readable error messages
     module MatcherConfiguration
@@ -246,22 +327,37 @@ module ArQueryMatchers
     end
 
     module MatcherErrors
-      # Show the difference between expected and actual values with one value
-      # per line. This is done by hand because as of this writing the author
-      # doesn't understand how RSpec does its nice hash diff printing.
-      def difference(keys)
-        max_key_length = keys.reduce(0) { |max, key| [max, key.size].max }
+      def create_display_string(max_key_length, key, left, right, show_values)
+        diff_array = right - left
+        diff_array = left - right if diff_array.empty?
+        "#{key.rjust(max_key_length, ' ')} – expected: #{left}, got: #{right} #{"(difference: #{diff_array})" if show_values}"
+      end
 
+      def loop_through_keys(keys, transformed_expected, show_values)
+        max_key_length = keys.reduce(0) { |max, key| [max, key.size].max }
         keys.map do |key|
-          left = expected.fetch(key, 0)
-          right = @query_stats.queries.fetch(key, {}).fetch(:count, 0)
+          left = transformed_expected.fetch(key, show_values ? [] : 0)
+          left = [left] unless left.is_a?(Array) || show_values
 
-          diff = "#{'+' if right > left}#{right - left}"
+          right = @query_stats.queries.fetch(key, {})
+          right = show_values ? right.fetch(:values, []) : right.fetch(:count, 0)
 
-          "#{key.rjust(max_key_length, ' ')} – expected: #{left}, got: #{right} (#{diff})"
+          create_display_string(max_key_length, key, left, right, show_values)
         end.compact
       end
 
+      # Show the difference between expected and actual values with one value
+      # per line. This is done by hand because as of this writing the author
+      # doesn't understand how RSpec does its nice hash diff printing.
+      def difference(keys, show_values: false)
+        transformed_expected = expected
+        if show_values
+          transformed_expected = expected.transform_values { |v| v.is_a?(Array) ? v : [v] }
+        end
+
+        loop_through_keys keys, transformed_expected, show_values
+      end
+
       def source_lines(keys)
         line_frequency = @query_stats.query_lines_by_frequency
         keys_with_source_lines = keys.select { |key| line_frequency[key].present? }
@@ -281,10 +377,33 @@ module ArQueryMatchers
         "Expected ActiveRecord to not #{crud_operation} any records, got #{@query_stats.query_counts}\n\nWhere unexpected queries came from:\n\n#{source_lines(@query_stats.query_counts.keys).join("\n")}"
       end
 
-      def expectation_failed_message(crud_operation)
+      def reject_record(subset, current_expected, key, ignore_missing)
+        if subset && !current_expected[key].nil?
+          if ignore_missing
+            @query_stats.queries[key][:values].empty? || (current_expected[key] - @query_stats.queries[key][:values]).empty?
+          else
+            (current_expected[key] - @query_stats.queries[key][:values]).empty?
+          end
+        else
+          ignore_missing || @query_stats.queries[key][:values] == current_expected[key]
+        end
+      end
+
+      def filter_model_names(subset, show_values, ignore_missing)
         all_model_names = expected.keys + @query_stats.queries.keys
-        model_names_with_wrong_count = all_model_names.reject { |key| expected[key] == @query_stats.queries[key][:count] }.uniq
-        "Expected ActiveRecord to #{crud_operation} #{expected}, got #{@query_stats.query_counts}\nExpectations that differed:\n#{difference(model_names_with_wrong_count).join("\n")}\n\nWhere unexpected queries came from:\n\n#{source_lines(model_names_with_wrong_count).join("\n")}"
+        if show_values
+          transformed_expected = expected.transform_values { |v| v.is_a?(Array) ? v : [v] }
+          all_model_names.reject { |key| reject_record(subset, transformed_expected, key, ignore_missing) }.uniq
+        else
+          all_model_names.reject { |key| expected[key] == @query_stats.queries[key][:count] }.uniq
+        end
+      end
+
+      def expectation_failed_message(crud_operation, show_values: false, subset: false, ignore_missing: false)
+        model_names_with_wrong_count = filter_model_names(subset, show_values, ignore_missing)
+        message = "Expected ActiveRecord to #{crud_operation} #{expected}, got #{show_values ? @query_stats.query_values : @query_stats.query_counts}\n"
+        message += "Expectations that differed:\n#{difference(model_names_with_wrong_count, show_values: show_values).join("\n")}" if show_values
+        message + "\n\nWhere unexpected queries came from:\n\n#{source_lines(model_names_with_wrong_count).join("\n")}"
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar-query-matchers
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Matan Zruya
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-28 00:00:00.000000000 Z
+date: 2025-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -163,6 +163,8 @@ files:
 - README.md
 - lib/ar_query_matchers.rb
 - lib/ar_query_matchers/queries/create_counter.rb
+- lib/ar_query_matchers/queries/field_counter.rb
+- lib/ar_query_matchers/queries/field_name.rb
 - lib/ar_query_matchers/queries/load_counter.rb
 - lib/ar_query_matchers/queries/model_name.rb
 - lib/ar_query_matchers/queries/query_counter.rb
@@ -177,7 +179,7 @@ metadata:
   homepage_uri: https://github.com/Gusto/ar-query-matchers
   source_code_uri: https://github.com/Gusto/ar-query-matchers
   changelog_uri: https://github.com/Gusto/ar-query-matchers/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -192,8 +194,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Ruby test matchers for instrumenting ActiveRecord query counts
 test_files: []