ar-query-matchers 0.8.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bbbb0ab94d0e842a364dbe7d970900fa6bcdf2b6d9d3a0a2eb3cfac96df9efd
-  data.tar.gz: 6650c24207bd4a7d47077ec311b05530eab74dca5b097537ca554023f8cd92ce
+  metadata.gz: 85641d6041fd4ef3611a70e0f3b5481e9e4d80d23b1ee0a229e5006831367464
+  data.tar.gz: c27f7061b4b22ff584c90a5d4122f2c71b4e5a452f59c432f215fdbf45b01be1
 SHA512:
-  metadata.gz: 1b548ed7b6d0d3ad9d144f2994846c84e087c420f5390cfe2ad957b3a598383c07576d5d51e5cb209bc589e928ad92fd7af56c1c40c73b198d510dab0721c50e
-  data.tar.gz: e27df0c699c8c2021d0e146f6070cba820226e2ca4dcc2258bcde3247356b4007600433cf928da00bda8585d1a32e8c638097ec95ecfa2e524db5e1194c4a5b4
+  metadata.gz: 0aa94f77507d3bd00e0ca8b982a665df41ececebc657298241271c2e9d7e15a42e84a387b843537f63711e520b56c5b6c37c1b365e9e73930903269716b7158d
+  data.tar.gz: 3605475400e443fb20782d5f651aed89d359ff244c2d8df82d9b02989d957162aa366d45a3cf44ae9cce6afffc29ee46c10a9e0e9024958bbdf150e2c2c56a78

data/README.md

@@ -42,7 +42,7 @@ This gem defines a few categories of matchers:
 Each matcher category includes 3 assertions, for example, for the Load category, you could use the following assertions:
 - **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_models**: No models are allowed to be loaded.
+- **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.
 
 
@@ -72,7 +72,7 @@ expect { some_code() }.to only_load_at_most_models(
 
 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/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,7 +17,7 @@ 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/
+        MODEL_LOAD_PATTERN = /\A(?<field_name>[\w:]+)/
 
         # Matches unnamed SQL operations like the following:
         # "SELECT COUNT(*) FROM `users` ..."
@@ -27,7 +27,7 @@ module ArQueryMatchers
           # 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
@@ -74,6 +82,15 @@ module ArQueryMatchers
       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.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.8.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Matan Zruya
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-27 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.4.10
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Ruby test matchers for instrumenting ActiveRecord query counts
 test_files: []