Add field counters to allow you to check if a field was referenced

Author: fuzzyrichie

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,60 @@ 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.map { |k, v| [k, v.kind_of?(Array) ? v : [v]] }.to_h
+
+        match do |block|
+          @query_stats = Queries::FieldCounter.instrument(&block)
+          expected == @query_stats.query_values
+        end
+
+        def failure_text
+          expectation_failed_message('query_by', 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.map { |k, v| [k, v.kind_of?(Array) ? v : [v]] }.to_h
+
+        match do |block|
+          @query_stats = Queries::FieldCounter.instrument(&block)
+          _expected == @query_stats.query_values.select{ |k,v| _expected.keys.include?(k) }
+        end
+
+        def failure_text
+          expectation_failed_message('query_by', true, 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
@@ -249,16 +304,26 @@ 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)
+      def difference(keys, values_only=false)
         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 = expected.fetch(key, values_only ? [] : 0)
+          right = @query_stats.queries.fetch(key, {})
+          if values_only
+            left = [left] if not left.kind_of?(Array)
+            right = right.fetch(:values, [])
+          else
+            right = right.fetch(:count, 0)
+          end
 
-          diff = "#{'+' if right > left}#{right - left}"
+          if values_only
+            "#{key.rjust(max_key_length, ' ')} – expected: #{left}, got: #{right}"
+          else
+            diff = "#{'+' if right > left}#{right - left}"
+            "#{key.rjust(max_key_length, ' ')} – expected: #{left}, got: #{right} (#{diff})"
+          end
 
-          "#{key.rjust(max_key_length, ' ')} – expected: #{left}, got: #{right} (#{diff})"
         end.compact
       end
 
@@ -281,10 +346,24 @@ 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 expectation_failed_message(crud_operation, values_only=false, subset=false)
+        if values_only
+          _expected = expected.map { |k, v| [k, v.kind_of?(Array) ? v : [v]] }.to_h
+          expected = _expected
+        end
         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 values_only
+          model_names_with_wrong_count = all_model_names.reject { |key|
+            if subset && !expected[key].nil?
+              (expected[key] - @query_stats.queries[key][:values]).empty?
+            else
+              @query_stats.queries[key][:values] == expected[key]
+            end
+          }.uniq
+        else
+          model_names_with_wrong_count = all_model_names.reject { |key| expected[key] == @query_stats.queries[key][:count] }.uniq
+        end
+        "Expected ActiveRecord to #{crud_operation} #{expected}, got #{values_only ? @query_stats.query_values : @query_stats.query_counts}\nExpectations that differed:\n#{difference(model_names_with_wrong_count, values_only).join("\n")}\n\nWhere unexpected queries came from:\n\n#{source_lines(model_names_with_wrong_count).join("\n")}"
       end
     end
   end

lib/ar_query_matchers/queries/field_counter.rb

@@ -0,0 +1,52 @@
+# 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
+
+      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
+          if cleaned_value == value
+            cleaned_value = value.to_i
+          end
+
+          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)
+          if sql.match(/INSERT/)
+            debugger
+          end
+
+          FieldName.new(select_field_query[:field_name], cleanup(select_field_query[:field_value])) if select_field_query
+        end
+      end
+    end
+  end
+end

lib/ar_query_matchers/queries/field_name.rb

@@ -0,0 +1,17 @@
+# 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.
+    # its accepts a name of an ActiveRecord model, for example: 'Company'.
+    class FieldName
+      attr_reader(:model_name)
+      attr_reader(:model_value)
+
+      def initialize(model_name, model_value)
+        @model_name = model_name
+        @model_value = model_value
+      end
+    end
+  end
+end

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` ..."

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
@@ -81,12 +89,14 @@ def to_proc(queries)
           # 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][:values].append(model_obj&.model_value) if model_obj.respond_to?(:model_value)
             queries[model_name][:time] += (finish - start).round(6) # Round to microseconds
           end
         end