miscellany 0.1.31 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e8daf2119169fb42523d39ed55e69d90dc43db0bed0178971b60aa279797a3e
-  data.tar.gz: 96716ff17fbc11304ead76e6c294888db6b48fad5f3fa7ea214b6fb445870260
+  metadata.gz: 1c17779818cbaa02c273b128b603a78ffd7326ddd11fd5128aa44e67186be998
+  data.tar.gz: f0955c93b216e1e4916c20675868a9232d8b2aa53d019f512a29d3015b71ba80
 SHA512:
-  metadata.gz: c0320bcd305fbbaa8588c705293ae81be13cd20e2b41cad37aaa56e4fc84c1a7414a79bc15f3d22337bc376307a56064df26d238a979f4a0da5edfd1567dfd4f
-  data.tar.gz: 6f6f45648681860132544efc225e35d0575c7cf6f8a0b478ade5fe4defab8be9a498dd26d4af3f4159c5737146cee5332c31d7c912b10a1c083c126205f87423
+  metadata.gz: 9a8d4a0ef8d98347690dffd6605fac5b458610045280e97f2916e5f8a12c830d9b3949a1f319868cc816c1a99327afd3105e0a3ad52dae17a93c9746a6e14edd
+  data.tar.gz: fae23a0570af847e51d455bd3a3ecb22f52dfc59dc2f00882e0c5515b28b4b192a190f0120b47e8c5f5047ef7542195bb8c426bfd7adbc2449cdad15aaa3c6dd

data/lib/miscellany/active_record/arbitrary_prefetch.rb

@@ -1,9 +1,10 @@
 # Add support for creating arbitrary associations when using ActiveRecord
 # Adds a `prefetch` method to ActiveRecord Queries.
 #   This method accepts a Hash. The keys of the Hash represent how the Association will be made available.
-#   The values of the Hash may be an array of [Symbol, Relation] or another (filtered) Relation.
+#   The values of the Hash may be an array of [Symbol, Relation or Proc], a Proc, or another (filtered) Relation.
 #   Objects are queried from an existing Association on the model. This Association is detemrined
-#   by either the Symbol when an array is passed, or by finding an Assoication for the passed Relation's model
+#   by either the Symbol when an array is passed, the association named in a Proc,
+#   or by finding an Assoication for the passed Relation's model
 module Miscellany
   module ArbitraryPrefetch
     ACTIVE_RECORD_VERSION = ::Gem::Version.new(::ActiveRecord::VERSION::STRING).release
@@ -66,6 +67,43 @@ module Miscellany
       end
     end
 
+    # Evaluates a prefetch scope block such as `->{ comments.where(favorite: true) }`.
+    # Association names answer with an unscoped Relation on the association's target class
+    # and record which association the prefetch is based off of. Everything else falls
+    # through to the block's original `self`, so surrounding helper methods still work.
+    class ScopeResolver < BasicObject
+      attr_reader :source_key
+
+      def initialize(model, fallback)
+        @model = model
+        @fallback = fallback
+        @source_key = nil
+      end
+
+      def __evaluate__(block)
+        [instance_exec(&block), @source_key]
+      end
+
+      def method_missing(name, *args, &block)
+        reflection = @model.reflections[name.to_s]
+
+        if reflection.nil?
+          unless @fallback
+            ::Kernel.raise ::NameError, "undefined local variable or method `#{name}' for prefetch scope on #{@model}"
+          end
+          return @fallback.__send__(name, *args, &block)
+        end
+
+        if @source_key && @source_key != name.to_sym
+          ::Kernel.raise ::ArgumentError,
+            "prefetch scope references two associations (#{@source_key} and #{name}); it may only build off of one"
+        end
+
+        @source_key = name.to_sym
+        reflection.klass.all
+      end
+    end
+
     module ActiveRecordPatches
       module BasePatch
         extend ActiveSupport::Concern
@@ -104,7 +142,7 @@ module Miscellany
         def add_prefetches!(kwargs)
           return unless kwargs.present?
 
-          if Rails.version < "7.2"
+          if ACTIVE_RECORD_VERSION < ::Gem::Version.new('7.2.0')
             assert_mutability!
           else
             assert_modifiable!
@@ -118,8 +156,10 @@ module Miscellany
         end
 
         def normalize_prefetch_options(attr, opts)
+          opts = resolve_prefetch_scope(opts) if opts.is_a?(Proc)
+
           norm = if opts.is_a?(Array)
-              { relation: opts[0], queryset: opts[1] }
+              { relation: opts[0], queryset: prefetch_queryset(opts[0], opts[1]) }
             elsif opts.is_a?(ActiveRecord::Relation)
               rel_name = opts.model.name.underscore
               rel = (model.reflections[rel_name] || model.reflections[rel_name.pluralize])&.name
@@ -133,6 +173,28 @@ module Miscellany
 
           norm
         end
+
+        # `->{ comments.where(favorite: true) }` - pull both the base association and the
+        # filtered queryset out of the block. Blocks that never name an association
+        # (`->{ Comment.where(...) }`) fall back to inferring it from the Relation's model.
+        def resolve_prefetch_scope(block)
+          raise ArgumentError, "prefetch scopes do not accept arguments" if block.arity > 0
+
+          fallback = block.binding.receiver rescue nil
+          queryset, source_key = ScopeResolver.new(model, fallback).__evaluate__(block)
+          source_key ? [source_key, queryset] : queryset
+        end
+
+        # `[:comments, ->{ where(favorite: true) }]` - evaluate the block against the
+        # named association, the same way a Rails association scope is evaluated.
+        def prefetch_queryset(relation, queryset)
+          return queryset unless queryset.is_a?(Proc)
+
+          reflection = model.reflections[relation.to_s]
+          raise ArgumentError, "#{model} has no association named #{relation}" unless reflection
+
+          reflection.klass.all.instance_exec(&queryset)
+        end
       end
 
       module Relation

data/lib/miscellany/active_record/complex_query.rb

@@ -56,7 +56,7 @@ module Miscellany
       conn = ActiveRecord::Base.connection
       tbl = "#{self.class.name.split('::').last.underscore}_#{SecureRandom.hex[0..10]}"
 
-      conn.execute("CREATE TEMP TABLE #{tbl} AS (#{sql})")
+      conn.execute("CREATE TEMP TABLE #{tbl} AS #{sql}")
 
       offset = 0
       loop do
@@ -64,10 +64,12 @@ module Miscellany
           "SELECT * FROM #{tbl} LIMIT #{of} OFFSET #{offset}",
         )
         batch = batch.map(&:with_indifferent_access)
+        # Checked before yielding, so consumers never see an empty batch.
+        break if batch.empty?
+
         augment_batch(batch)
         yield batch
         offset += of
-        break if batch.empty?
       end
     ensure
       conn.execute("DROP TABLE IF EXISTS #{tbl}")
@@ -86,8 +88,9 @@ module Miscellany
     end
 
     def valid_sort?(sort)
-      sort_parser.valid?(sort)
       return false unless sort.present?
+
+      sort_parser.valid?(sort)
     end
 
     protected
@@ -111,7 +114,10 @@ module Miscellany
     end
 
     def valid_sorts
-      return self.class::SORTABLE_COLUMNS.with_indifferent_access if defined?(self.class::SORTABLE_COLUMNS)
+      # SortLang::Parser expects an array of sort specs (strings and/or hashes);
+      # wrap the SORTABLE_COLUMNS hash so it is treated as a single hash entry
+      # rather than iterated into [key, value] pairs.
+      return [self.class::SORTABLE_COLUMNS.with_indifferent_access] if defined?(self.class::SORTABLE_COLUMNS)
     end
 
     def sort_parser
@@ -119,7 +125,9 @@ module Miscellany
     end
 
     def sanitize_sql(*args)
-      ApplicationRecord.sanitize_sql(args)
+      # ActiveRecord::Base rather than ApplicationRecord: the latter is a host-app
+      # constant this gem cannot count on existing.
+      ActiveRecord::Base.sanitize_sql(args)
     end
 
     def filters
@@ -156,7 +164,8 @@ module Miscellany
     end
 
     def _parse_datetime_range(range)
-      range = [filters["#{key}_start"], filters["#{key}_end"]] if range.is_a?(String) || range.is_a?(Symbol)
+      # A String/Symbol names a pair of "<key>_start"/"<key>_end" filters.
+      range = [filters["#{range}_start"], filters["#{range}_end"]] if range.is_a?(String) || range.is_a?(Symbol)
       range = range.map{|v| _parse_datetime(v)}
       range
     end

data/lib/miscellany/batching_csv_processor.rb

@@ -1,3 +1,5 @@
+require 'csv'
+
 module Miscellany
   class BatchingCsvProcessor
     attr_accessor :csv, :file_name
@@ -45,7 +47,7 @@ module Miscellany
     end
 
     def batch_rows_to_models(rows)
-      rows.map { |row| build_model_from_row(row) }.reject! { |inst| inst.nil? || !inst.changed? }
+      rows.map { |row| build_model_from_row(row) }.reject { |inst| inst.nil? || !inst.changed? }
     end
 
     def build_model_from_row(row)
@@ -59,7 +61,7 @@ module Miscellany
       nil
     rescue StandardError => err
       log_line_error('An Internal Error Occurred', row[:line_number], exception: err)
-      Raven.capture_exception(err)
+      Raven.capture_exception(err) if defined?(Raven)
       nil
     end
 

data/lib/miscellany/controller/http_error_handling.rb

@@ -52,10 +52,12 @@ module Miscellany
       status = err.status if err.is_a?(HttpError) && status.nil?
       status ||= 400
       message ||= err.message
-      message.message.call(err) if message.is_a?(Proc)
+      message = message.call(err) if message.is_a?(Proc)
       response_json = { status: status }
       response_json[:message] = message if message.present?
-      response_json.merge!(err.extra)
+      # rescue_with_http_error routes ordinary exceptions here too, and only
+      # HttpError carries extra.
+      response_json.merge!(err.extra) if err.respond_to?(:extra) && err.extra.present?
       render json: response_json, status: status
     end
   end

data/lib/miscellany/controller/sliced_response.rb

@@ -92,15 +92,24 @@ module Miscellany
             elsif arg[:slice].present?
               slice_bounds = arg[:slice].split(':').map(&:to_i)
             else
-              page_size = slice[:page_size] = (arg[:page_size] || options[:default_page_size]).to_i
-              page_number = slice[:page_number] = (arg[:page] || 1).to_i
+              # :default_page_size and :default_size are two names callers use for the
+              # same thing; honor either so a caller passing only one isn't left with 0.
+              default_page_size = options[:default_page_size] || options[:default_size]
+              page_size = slice[:page_size] = (arg[:page_size] || default_page_size).to_i
+              if page_size < 1
+                raise HttpErrorHandling::HttpError.new(message: "page_size must be at least 1")
+              end
+
+              # Clamped rather than rejected, so that a page past either end of the
+              # collection stays a valid (if empty) request. Matches ComplexQuery#page.
+              page_number = slice[:page_number] = [(arg[:page] || 1).to_i, 1].max
               slice_bounds = [(page_number - 1) * page_size, page_number * page_size]
             end
 
             begin
               slice[:sort] = options[:sort_parser]&.parse(arg[:sort], ignore_errors: true, default: true)
             rescue Miscellany::SortLang::Parser::SortParsingError => e
-              raise HttpErrorHandling::HttpError, message: e.message
+              raise HttpErrorHandling::HttpError.new(message: e.message)
             end
           end
 
@@ -110,10 +119,10 @@ module Miscellany
           end
 
           if slice[:slice_end] == -1
-            raise HttpErrorHandling::HttpError, message: "cannot request whole collection" unless options[:allow_all]
+            raise HttpErrorHandling::HttpError.new(message: "cannot request whole collection") unless options[:allow_all]
           else
             if options[:max_size] && (slice[:slice_end] - slice[:slice_start]) > [options[:max_size], options[:default_size]].max
-              raise HttpErrorHandling::HttpError, message: "cannot request more than #{options[:max_size]} objects"
+              raise HttpErrorHandling::HttpError.new(message: "cannot request more than #{options[:max_size]} objects")
             end
           end
         end

data/lib/miscellany/local_lru_cache.rb

@@ -6,12 +6,11 @@ module Miscellany
     end
 
     def max_size=(size)
-      raise ArgumentError.new(:max_size) if @max_size < 1
+      raise ArgumentError.new(:max_size) if size < 1
       @max_size = size
-      if @max_size < @data.size
-        @data.keys[0..@max_size-@data.size].each do |k|
-          @data.delete(k)
-        end
+      # Evict least-recently-used entries (oldest first) until we fit.
+      while @data.size > @max_size
+        @data.delete(@data.first[0])
       end
     end
 
@@ -43,7 +42,7 @@ module Miscellany
     end
 
     def each
-      @data.reverse.each do |pair|
+      to_a.each do |pair|
         yield pair
       end
     end

data/lib/miscellany/param_validator.rb

@@ -5,6 +5,20 @@ module Miscellany
 
     delegate_missing_to :context
 
+    # Raised when a `type:` has no coercion rule at all. That is a mistake in the
+    # validator definition rather than bad input, so it escapes the ArgumentError
+    # rescue in `coerce_type` instead of becoming a validation error.
+    class UnsupportedTypeError < ArgumentError; end
+
+    # Returned by `coerce_single_type` when no coercion rule matched. Distinct from
+    # nil, which is a legitimate coerced value.
+    UNSUPPORTED_TYPE = Object.new.freeze
+
+    # Significant digits used when coercing a non-String to BigDecimal, where
+    # BigDecimal() requires an explicit precision. Strings pass 0 instead and are
+    # parsed exactly.
+    DEFAULT_PRECISION = Float::DIG + 1
+
     TIME_TYPES = [Date, DateTime, Time].freeze
 
     CHECKS = %i[type specified present default transform in block items pattern].freeze
@@ -93,7 +107,9 @@ module Miscellany
         next if params[pk].nil?
 
         run_check[:pattern] do |pattern|
-          return true if params[pk].to_s.match?(pattern)
+          # `next`, not `return` - a `return` here would exit `parameter` entirely,
+          # skipping the remaining checks and the final `@errors.merge!`.
+          next true if params[pk].to_s.match?(pattern)
 
           "must match pattern: #{pattern.inspect}"
         end
@@ -242,9 +258,20 @@ module Miscellany
 
       types = Array(opts[:type])
       types.each do |t|
-        params[key] = coerce_single_type(value, t, opts)
+        coerced = begin
+                    coerce_single_type(value, t, opts)
+                  rescue ArgumentError, TypeError
+                    next
+                  end
+
+        # Raised outside the rescue above so it reaches the caller rather than
+        # being reported as an ordinary coercion failure.
+        if coerced.equal?(UNSUPPORTED_TYPE)
+          raise UnsupportedTypeError, "unsupported type #{t.inspect} for #{key.inspect}"
+        end
+
+        params[key] = coerced
         return true
-      rescue ArgumentError, TypeError => err
       end
 
       "'#{value}' could not be cast to a #{types.join(' or a ')}"
@@ -302,10 +329,15 @@ module Miscellany
 
       # BigDecimals
       if type == BigDecimal
-        param = param.delete('$,').strip.to_f if param.is_a?(String)
-        return BigDecimal(param, (options[:precision] || DEFAULT_PRECISION))
+        # Strings are handed to BigDecimal directly rather than via to_f, so that
+        # digits beyond Float's range survive. A precision of 0 tells BigDecimal to
+        # take it from the literal.
+        return BigDecimal(param.delete('$,').strip, options[:precision] || 0) if param.is_a?(String)
+
+        return BigDecimal(param, options[:precision] || DEFAULT_PRECISION)
       end
-      nil
+
+      UNSUPPORTED_TYPE
     end
 
     def normalize_opts(*args, **kwargs, &blk)
@@ -315,7 +347,8 @@ module Miscellany
         type = args.delete(:items) ? :all_items : :all_block
         set_hash_key(norm, type, blk)
       end
-      set_hash_key(norm, :type, args.pop(0)) if args.present?
+      # `args.pop`, not `args.pop(0)` - the latter removes nothing and returns [].
+      set_hash_key(norm, :type, args.pop) if args.present?
 
       # Stage 2
       norm = convert_flags(norm)
@@ -324,7 +357,7 @@ module Miscellany
       norm = convert_prefixed_keys(norm)
 
       extra_kwargs = norm.keys - PREFIXES - NON_PREFIXED
-      raise ArgumentError, "Unrecognized postitional arguments: #{args.inspect}" if args.present?
+      raise ArgumentError, "Unrecognized positional arguments: #{args.inspect}" if args.present?
       raise ArgumentError, "Unrecognized keyword arguments: #{extra_kwargs.inspect}" if extra_kwargs.present?
 
       norm

data/lib/miscellany/sort_lang.rb

@@ -91,13 +91,15 @@ module Miscellany
 
           if m.nil?
             next if ignore_errors
-            raise SortParsingError, message: 'Could not parse sort parameter'
+            # Passed positionally - `raise Klass, message: '...'` would hand the Hash
+            # itself to the exception and surface it as the message.
+            raise SortParsingError, "could not parse sort parameter: #{s.strip.inspect}"
           end
 
           resolved_sort = @sorts_map[m[1]]
           unless resolved_sort.present?
             next if ignore_errors
-            raise SortParsingError, message: 'Could not parse sort parameter'
+            raise SortParsingError, "unknown sort column: #{m[1].inspect}"
           end
 
           sort = resolved_sort.dup

data/lib/miscellany/version.rb

@@ -1,3 +1,3 @@
 module Miscellany
-  VERSION = "0.1.31".freeze
+  VERSION = "0.2.0".freeze
 end

data/lib/miscellany.rb

@@ -1,7 +1,15 @@
 
+# Required explicitly rather than relying on the host app to have loaded them
+# first: the files below reference ActiveRecord and ActiveSupport at load time.
+require "active_support"
+require "active_support/core_ext"
 require "active_support/lazy_load_hooks"
+require "active_record"
+require "bigdecimal"
+require "bigdecimal/util"
 
-Dir[File.dirname(__FILE__) + "/miscellany/**/*.rb"].each { |file| require file }
+# Sorted so load order does not depend on the filesystem.
+Dir[File.dirname(__FILE__) + "/miscellany/**/*.rb"].sort.each { |file| require file }
 
 module Miscellany
 

data/miscellany.gemspec

@@ -23,13 +23,15 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'rails', '>= 5', '< 9.0'
+  # csv stopped being a default gem in Ruby 3.4; BatchingCsvProcessor requires it.
+  spec.add_dependency 'csv'
   # spec.add_dependency 'activerecord', '>= 5', '< 6.3'
   # spec.add_dependency 'activesupport', '>= 5', '< 6.3'
 
   spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'appraisal', '~> 2.4'
   spec.add_development_dependency 'database_cleaner', '>= 1.2'
   spec.add_development_dependency 'rspec', '~> 3'
-  spec.add_development_dependency 'sqlite3', '~> 1.3'
   spec.add_development_dependency 'with_model'
   spec.add_development_dependency 'goldiloader'
 end

data/spec/miscellany/arbitrary_prefetch_spec.rb

@@ -37,6 +37,51 @@ describe Miscellany::ArbitraryPrefetch do
       end
     end
 
+    context 'given a proc' do
+      it 'builds off of the association named in the proc' do
+        posts = Post.prefetch(favorite_comment: -> { comments.where(favorite: true) })
+        expect(posts[0].favorite_comment).to be_a Comment
+        expect(posts[0].favorite_comment.favorite).to eq true
+      end
+
+      it 'works with a plural key' do
+        posts = Post.prefetch(non_favorite_comments: -> { comments.where(favorite: nil) })
+        expect(posts[0].non_favorite_comments.length).to eq 4
+      end
+
+      it 'falls back to the Relation model when no association is named' do
+        posts = Post.prefetch(favorite_comment: -> { Comment.where(favorite: true) })
+        expect(posts[0].favorite_comment).to be_a Comment
+      end
+
+      it 'resolves non-association methods against the enclosing scope' do
+        def favorite_flag = true
+
+        posts = Post.prefetch(favorite_comment: -> { comments.where(favorite: favorite_flag) })
+        expect(posts[0].favorite_comment).to be_a Comment
+      end
+
+      it 'rejects a proc that takes arguments' do
+        expect {
+          Post.prefetch(favorite_comment: ->(scope) { scope })
+        }.to raise_error(ArgumentError, /do not accept arguments/)
+      end
+    end
+
+    context 'given a tuple with a proc' do
+      it 'evaluates the proc against the named association' do
+        posts = Post.prefetch(favorite_comment: [:comments, -> { where(favorite: true) }])
+        expect(posts[0].favorite_comment).to be_a Comment
+        expect(posts[0].favorite_comment.favorite).to eq true
+      end
+
+      it 'raises on an unknown association' do
+        expect {
+          Post.prefetch(favorite_comment: [:nope, -> { where(favorite: true) }])
+        }.to raise_error(ArgumentError, /no association named nope/)
+      end
+    end
+
     context 'prefetch is plural' do
       it 'returns an Array' do
         posts = Post.prefetch(non_favorite_comments: Comment.where(favorite: nil))
@@ -136,5 +181,11 @@ describe Miscellany::ArbitraryPrefetch do
     end
 
     include_examples "general specs"
+
+    it 'rejects a proc that names two associations' do
+      expect {
+        Post.prefetch(favorite_comment: -> { comments.where(id: interims.select(:comment_id)) })
+      }.to raise_error(ArgumentError, /may only build off of one/)
+    end
   end
 end

data/spec/miscellany/batch_matcher_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+RSpec.describe Miscellany::BatchMatcher do
+  describe 'simple (single-model) matching' do
+    with_model :Rule do
+      table do |t|
+        t.string :import_id
+        t.string :label
+      end
+    end
+
+    let!(:rule_a) { Rule.create!(import_id: 'IMP-A', label: 'Alpha') }
+    let!(:rule_b) { Rule.create!(import_id: 'IMP-B', label: 'Beta') }
+
+    # [csv_key, db_key, human_name]; first entry is the primary column.
+    let(:columns) { [[:rule_id, :id, 'ID'], [:rule_import_id, :import_id, 'Import ID']] }
+    let(:rows) do
+      [
+        { rule_id: rule_a.id, rule_import_id: 'IMP-A' },
+        { rule_id: rule_b.id, rule_import_id: 'IMP-B' },
+      ]
+    end
+
+    def matcher(opts = {})
+      described_class.new(Rule, rows, **{ columns: columns }.merge(opts))
+    end
+
+    describe '#get_for_row!' do
+      it 'matches on the primary column' do
+        expect(matcher.get_for_row!(rule_id: rule_a.id)).to eq rule_a
+      end
+
+      it 'matches on a secondary column' do
+        expect(matcher.get_for_row!(rule_import_id: 'IMP-B')).to eq rule_b
+      end
+
+      it 'matches when consistent values are given for multiple columns' do
+        expect(matcher.get_for_row!(rule_id: rule_a.id, rule_import_id: 'IMP-A')).to eq rule_a
+      end
+
+      it 'raises RecordNotFound when nothing matches' do
+        expect { matcher.get_for_row!(rule_import_id: 'NOPE') }
+          .to raise_error(ActiveRecord::RecordNotFound, /Import ID/)
+      end
+    end
+
+    describe '#get_for_row' do
+      it 'returns nil instead of raising when nothing matches' do
+        expect(matcher.get_for_row(rule_import_id: 'NOPE')).to be_nil
+      end
+
+      it 'returns the record when it matches' do
+        expect(matcher.get_for_row(rule_id: rule_b.id)).to eq rule_b
+      end
+    end
+
+    describe '#get_primary_for_row!' do
+      it 'returns the primary key value for a primary-column row' do
+        expect(matcher.get_primary_for_row!(rule_id: rule_a.id)).to eq rule_a.id.to_s
+      end
+
+      it 'resolves the primary key value from a secondary column' do
+        expect(matcher.get_primary_for_row!(rule_import_id: 'IMP-B')).to eq rule_b.id.to_s
+      end
+    end
+
+    describe '#should_match?' do
+      it 'is true when any configured column has a value' do
+        expect(matcher.should_match?(rule_import_id: 'IMP-A')).to be true
+      end
+
+      it 'is false when no configured column has a value' do
+        expect(matcher.should_match?(unrelated: 'x')).to be false
+        expect(matcher.should_match?({})).to be false
+      end
+    end
+
+    describe 'validate_all' do
+      let(:conflicting_row) { { rule_id: rule_a.id, rule_import_id: 'IMP-B' } }
+
+      it 'raises when columns resolve to different records (default)' do
+        expect { matcher.get_for_row!(conflicting_row) }
+          .to raise_error(ActiveRecord::RecordNotFound, /resolved to different objects/)
+      end
+
+      it 'returns the first match when validation is disabled' do
+        expect(matcher(validate_all: false).get_for_row!(conflicting_row)).to eq rule_a
+      end
+    end
+  end
+
+  describe 'polymorphic matching' do
+    with_model :Account do
+      table { |t| t.integer :canvas_id }
+    end
+
+    with_model :Course do
+      table { |t| t.integer :canvas_id }
+    end
+
+    let!(:account) { Account.create!(canvas_id: 100) }
+    let!(:course) { Course.create!(canvas_id: 200) }
+
+    let(:columns) { [[:canvas_context_id, :canvas_id, 'Canvas ID']] }
+    let(:rows) do
+      [
+        { context_type: 'Account', canvas_context_id: 100 },
+        { context_type: 'Course', canvas_context_id: 200 },
+      ]
+    end
+
+    def matcher
+      described_class.new(
+        [Account, Course], rows,
+        polymorphic_on: :context_type,
+        columns: columns,
+      )
+    end
+
+    it 'resolves rows to the correct model based on the polymorphic type' do
+      expect(matcher.get_for_row!(rows[0])).to eq account
+      expect(matcher.get_for_row!(rows[1])).to eq course
+    end
+
+    it 'raises for an unknown polymorphic type' do
+      expect { matcher.get_for_row!(context_type: 'Widget', canvas_context_id: 1) }
+        .to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+end