Add field counters to allow you to check if a field was referenced (#37)

fuzzyrichie · web-flow · commit 5f7098ee490b · 2025-04-29T14:12:48.000-04:00
diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml
@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.7', '3.2']
+        ruby: ['3.2', '3.3']
         appraisal: ["rails-6", "rails-7"]
     steps:
     - uses: actions/checkout@v1
@@ -24,4 +24,4 @@ jobs:
         gem install bundler
         bundle install --jobs 4 --retry 3
         bundle exec appraisal install
-        bundle exec appraisal ${{ matrix.appraisal }} rake
+        bundle exec appraisal ${{ matrix.appraisal }} rake
diff --git a/lib/ar_query_matchers.rb b/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 @@ def failure_text
       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 @@ def supports_block_expectations?
     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 @@ def no_queries_fail_message(crud_operation)
         "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
diff --git a/lib/ar_query_matchers/queries/field_counter.rb b/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
diff --git a/lib/ar_query_matchers/queries/field_name.rb b/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
diff --git a/lib/ar_query_matchers/queries/load_counter.rb b/lib/ar_query_matchers/queries/load_counter.rb
@@ -17,7 +17,7 @@ def self.instrument(&block)
       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 @@ 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.
diff --git a/lib/ar_query_matchers/queries/query_counter.rb b/lib/ar_query_matchers/queries/query_counter.rb
@@ -44,6 +44,14 @@ def query_counts
           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 @@ def initialize(query_filter)
       # @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,21 +82,26 @@ def instrument(&block)
       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]
 
           # 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
diff --git a/spec/ar_query_matchers/mock_data_model.rb b/spec/ar_query_matchers/mock_data_model.rb
@@ -3,6 +3,7 @@
 # @mission Infrastructure
 # @team DEx
 
+require 'logger'
 require 'active_record'
 
 RSpec.shared_context('mock_data_model') do
