scimitar 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7c0cb7d5ff4346954d9aab0d83ae22fcd75fcc456b9be54d74e22334cf4e273
-  data.tar.gz: 47adaec88f0418f18294fb19374be773cbfafa6c94b8870e38a349f70a4c53b4
+  metadata.gz: 834a7c3f5dba88856dfea8fdfcc1807f49b36739d1c5886e0dc96e7ca5621642
+  data.tar.gz: 7aaa9fae826b8142c3c3418b825ca86c7de46bb543dcdfb19b042caea15f988e
 SHA512:
-  metadata.gz: 59a7f529e86667e14de8a6c0a0b0bc9a26cd53b21b53656be8b2f37d31e4cddcc1d0fccdefe2ff695d31baf19764489903a59e61f31e863e78c544f5dd24d550
-  data.tar.gz: '09d32ab29c325fa047f9e77daababa2bc763b79ee97e3b0b961202b60901b3ace406f5f66f63fd5c56b015a86e368294d4ec1e4b98b3588e7f4b75c72280e9e3'
+  metadata.gz: c3db5de7ca04d57be95f3638183936ab1cd4621b3aba22e0bcd6eaa3b2e876dfe2e79f86711da6de1106908ae96fd444c060b6bc10055e0b8f476faff6e18ca0
+  data.tar.gz: 701c4cb7d93f9dcfa89906bcfb222ba734d4ed83f0f2404969d8375df2a963c2376629508733d7e2852250d8652dac8e9ec07a6482f3a382fa64aaf2ac4ef9e0

data/app/models/scimitar/complex_types/base.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Scimitar
   module ComplexTypes
 
@@ -22,8 +24,48 @@ module Scimitar
       include Scimitar::Schema::DerivedAttributes
       include Scimitar::Errors
 
+      # Instantiates with attribute values - see ActiveModel::Model#initialize.
+      #
+      # Allows case-insensitive attributes given in options, by enumerating all
+      # instance methods that exist in the subclass (at the point where this
+      # method runs, 'self' is a subclass, unless someone instantiated this
+      # base class directly) and subtracting methods in the base class. Usually
+      # this leaves just the attribute accessors, with not much extra.
+      #
+      # Map a normalized case version of those names to the actual method names
+      # then for each key in the inbound options, normalize it and see if one
+      # of the actual case method names is available. If so, use that instead.
+      #
+      # Unmapped option keys will most likely have no corresponding writer
+      # method in the subclass and NoMethodError will therefore arise.
+      #
       def initialize(options={})
-        super
+        normalized_method_map     = HashWithIndifferentAccess.new
+        corrected_options         = {}
+        probable_accessor_methods = self.class.instance_methods - self.class.superclass.instance_methods
+
+        unless options.empty?
+          probable_accessor_methods.each do | method_name |
+            next if method_name.end_with?('=')
+            normalized_method_map[method_name.downcase] = method_name
+          end
+
+          options.each do | ambiguous_case_name, value |
+            normalized_name = ambiguous_case_name.downcase
+            corrected_name  = normalized_method_map[normalized_name]
+
+            if corrected_name.nil?
+              corrected_options[ambiguous_case_name] = value # Probably will lead to NoMethodError
+            else
+              corrected_options[corrected_name] = value
+            end
+          end
+
+          options = corrected_options
+        end
+
+        super # Calls into ActiveModel::Model
+
         @errors = ActiveModel::Errors.new(self)
       end
 

data/app/models/scimitar/resources/base.rb

@@ -11,10 +11,27 @@ module Scimitar
       validate :validate_resource
 
       def initialize(options = {})
-        flattended_attributes = flatten_extension_attributes(options)
-        attributes = flattended_attributes.with_indifferent_access.slice(*self.class.all_attributes)
-        super(attributes)
-        constantize_complex_types(attributes)
+        flattened_attributes = flatten_extension_attributes(options)
+        ci_all_attributes    = Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess.new
+        camel_attributes     = {}
+
+        # Create a map where values are the schema-correct-case attribute names
+        # and the values are set the same, but since the ci_all_attributes data
+        # type is HashWithIndifferentCaseInsensitiveAccess, lookups in this are
+        # case insensitive. Thus, arbitrary case input data can be mapped to
+        # the case correctness required for ActiveModel's attribute accessors.
+        #
+        self.class.all_attributes.each { |attr| ci_all_attributes[attr] = attr }
+
+        flattened_attributes.each do | key, value |
+          if ci_all_attributes.key?(key)
+            camel_attributes[ci_all_attributes[key]] = value
+          end
+        end
+
+        super(camel_attributes)
+        constantize_complex_types(camel_attributes)
+
         @errors = ActiveModel::Errors.new(self)
       end
 
@@ -109,6 +126,7 @@ module Scimitar
       def constantize_complex_types(hash)
         hash.with_indifferent_access.each_pair do |attr_name, attr_value|
           scim_attribute = self.class.complex_scim_attributes[attr_name].try(:first)
+
           if scim_attribute && scim_attribute.complexType
             if scim_attribute.multiValued
               self.send("#{attr_name}=", attr_value.map {|attr_for_each_item| complex_type_from_hash(scim_attribute, attr_for_each_item)})

data/app/models/scimitar/resources/mixin.rb

@@ -404,10 +404,10 @@ module Scimitar
         # Call ONLY for PATCH. For POST and PUT, see #from_scim!.
         #
         def from_scim_patch!(patch_hash:)
-          patch_hash.freeze()
-          scim_hash = self.to_scim(location: '(unused)').as_json()
+          frozen_ci_patch_hash = patch_hash.with_indifferent_case_insensitive_access().freeze()
+          ci_scim_hash         = self.to_scim(location: '(unused)').as_json().with_indifferent_case_insensitive_access()
 
-          patch_hash['Operations'].each do |operation|
+          frozen_ci_patch_hash['operations'].each do |operation|
             nature   = operation['op'   ]&.downcase
             path_str = operation['path' ]
             value    = operation['value']
@@ -440,22 +440,22 @@ module Scimitar
             if path_str.blank?
               extract_root = true
               path_str     = 'root'
-              scim_hash    = { 'root' => scim_hash }
+              ci_scim_hash = { 'root' => ci_scim_hash }.with_indifferent_case_insensitive_access()
             end
 
             self.from_patch_backend!(
               nature:        nature,
               path:          (path_str || '').split('.'),
               value:         value,
-              altering_hash: scim_hash
+              altering_hash: ci_scim_hash
             )
 
             if extract_root
-              scim_hash = scim_hash['root']
+              ci_scim_hash = ci_scim_hash['root']
             end
           end
 
-          self.from_scim!(scim_hash: scim_hash)
+          self.from_scim!(scim_hash: ci_scim_hash)
           return self
         end
 
@@ -542,20 +542,20 @@ module Scimitar
           #   ::scim_attributes_map.
           #
           #     {                                                     | {
-          #       "userName": "foo",                                  |   "id": "id",
-          #       "name": {                                           |   "externalId": :scim_uid",
-          #         "givenName": "Foo",                               |   "userName": :username",
-          #         "familyName": "Bar"                               |   "name": {
-          #       },                                                  |     "givenName": :first_name",
-          #       "active": true,                                     |     "familyName": :last_name"
+          #       "userName": "foo",                                  |   'id': :id,
+          #       "name": {                                           |   'externalId': :scim_uid,
+          #         "givenName": "Foo",                               |   'userName': :username,
+          #         "familyName": "Bar"                               |   'name': {
+          #       },                                                  |     'givenName': :first_name,
+          #       "active": true,                                     |     'familyName': :last_name
           #       "emails": [                                         |   },
-          #         {                                                 |   "emails": [
+          #         {                                                 |   'emails': [
           #           "type": "work",                  <------\       |     {
-          #           "primary": true,                         \------+---    "match": "type",
-          #           "value": "foo.bar@test.com"                     |       "with": "work",
-          #         }                                                 |       "using": {
-          #       ],                                                  |         "value": :work_email_address",
-          #       "phoneNumbers": [                                   |         "primary": true
+          #           "primary": true,                         \------+---    'match': 'type',
+          #           "value": "foo.bar@test.com"                     |       'with': 'work',
+          #         }                                                 |       'using': {
+          #       ],                                                  |         'value': :work_email_address,
+          #       "phoneNumbers": [                                   |         'primary': true
           #         {                                                 |       }
           #           "type": "work",                                 |     }
           #           "primary": false,                               |   ],
@@ -568,7 +568,7 @@ module Scimitar
           #         "location": "https://test.com/mock_users/42",     |       }
           #         "resourceType": "User"                            |     }
           #       },                                                  |   ],
-          #       "schemas": [                                        |   "active": :is_active"
+          #       "schemas": [                                        |   'active': :is_active
           #         "urn:ietf:params:scim:schemas:core:2.0:User"      | }
           #       ]                                                   |
           #     }                                                     |
@@ -600,7 +600,7 @@ module Scimitar
             scim_hash_or_leaf_value:,
             path: []
           )
-            attrs_map_or_leaf_value = attrs_map_or_leaf_value.with_indifferent_access() if attrs_map_or_leaf_value.instance_of?(Hash)
+            scim_hash_or_leaf_value = scim_hash_or_leaf_value.with_indifferent_case_insensitive_access() if scim_hash_or_leaf_value.is_a?(Hash)
 
             # We get the schema via this instance's class's resource type, even
             # if we end up in collections of other types - because it's *this*
@@ -668,7 +668,7 @@ module Scimitar
                 end # "map_entry&.each do | mapped_array_entry |"
 
               when Symbol # Setter/getter method at leaf position in attribute map
-                if path == ['externalId'] # Special case held only in schema base class
+                if path.length == 1 && path.first&.to_s&.downcase == 'externalid' # Special case held only in schema base class
                   mutable = true
                 else
                   attribute = resource_class.find_attribute(*path)
@@ -706,7 +706,8 @@ module Scimitar
           #
           # +altering_hash+:: The Hash to operate on at the current +path+. For
           #                   recursive calls, this will be some way down into
-          #                   the SCIM representation of 'self'.
+          #                   the SCIM representation of 'self'. MUST be a
+          #                   HashWithIndifferentCaseInsensitiveAccess.
           #
           # Note that SCIM PATCH operations permit *no* path for 'replace' and
           # 'add' operations, meaning "apply to whole object". To avoid special
@@ -715,6 +716,7 @@ module Scimitar
           # interest and supply this key as the sole array entry in +path+.
           #
           def from_patch_backend!(nature:, path:, value:, altering_hash:)
+            raise 'Case sensitivity violation' unless altering_hash.is_a?(Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess)
 
             # These all throw exceptions if data is not as expected / required,
             # any of which are rescued below.
@@ -752,6 +754,8 @@ module Scimitar
           # Happily throws exceptions if data is not as expected / required.
           #
           def from_patch_backend_traverse!(nature:, path:, value:, altering_hash:)
+            raise 'Case sensitivity violation' unless altering_hash.is_a?(Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess)
+
             path_component, filter = extract_filter_from(path_component: path.first)
 
             # https://tools.ietf.org/html/rfc7644#section-3.5.2.1
@@ -766,7 +770,7 @@ module Scimitar
             #
             # Harmless in this context for 'remove'.
             #
-            altering_hash[path_component] ||= {}
+            altering_hash[path_component] ||= Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess.new
 
             # Unless the PATCH is bad, inner data is an Array or Hash always as
             # by definition this method is only called at path positions above
@@ -784,7 +788,7 @@ module Scimitar
               # Same reason as section 3.5.2.1 / 3.5.2.3 RFC quotes above.
               #
               if nature != 'remove' && matched_hashes.empty?
-                new_hash = {}
+                new_hash = Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess.new
                 altering_hash[path_component] = [new_hash]
                 matched_hashes                = [new_hash]
               end
@@ -815,6 +819,8 @@ module Scimitar
           # Happily throws exceptions if data is not as expected / required.
           #
           def from_patch_backend_apply!(nature:, path:, value:, altering_hash:)
+            raise 'Case sensitivity violation' unless altering_hash.is_a?(Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess)
+
             path_component, filter = extract_filter_from(path_component: path.first)
             current_data_at_path   = altering_hash[path_component]
 
@@ -945,15 +951,32 @@ module Scimitar
           # Happily throws exceptions if data is not as expected / required.
           #
           def all_matching_filter(filter:, within_array:, &block)
-            filter_components = filter.split(' ')
-            raise "Unsupported matcher #{filter.inspect}" unless filter_components.size == 3 && filter_components[1].downcase == 'eq'
+            filter_components = filter.split(' ', 3)
 
             attribute = filter_components[0]
+            operator  = filter_components[1]
             value     = filter_components[2]
-            value     = value[1..-2] if value.start_with?('"') && value.end_with?('"')
+
+            # Quoted value includes closing quote but has data afterwards?
+            # Bad; implies extra conditions, e.g. '...eq "one two" and..." or
+            # just junk data.
+            #
+            # Value is *not* quoted but contains a space? Means there must be
+            # again either extra conditions or trailing junk data.
+            #
+            raise "Unsupported matcher #{filter.inspect}" if (
+              filter_components.size != 3         ||
+              operator.downcase != 'eq'           ||
+              value.strip.match?(/\".+[^\\]\".+/) || # Literal '"', any data, no-backslash-then-literal (unescaped) '"', more data
+              (!value.start_with?('"') && value.strip.include?(' '))
+            )
+
+            value = value[1..-2] if value.start_with?('"') && value.end_with?('"')
 
             within_array.each.with_index do | hash, index |
-              matched = hash.key?(attribute) && hash[attribute]&.to_s == value&.to_s
+              ci_hash = hash.with_indifferent_case_insensitive_access()
+              matched = ci_hash.key?(attribute) && ci_hash[attribute]&.to_s == value&.to_s
+
               yield(hash, index) if matched
             end
           end

data/app/models/scimitar/schema/base.rb

@@ -62,8 +62,10 @@ module Scimitar
           current_path_entry = path.shift()
           next if current_path_entry.is_a?(Integer) # Skip array indicies arising from multi-value attributes
 
+          current_path_entry = current_path_entry.to_s.downcase
+
           found_attribute = current_attributes.find do | attribute_to_check |
-            attribute_to_check.name == current_path_entry
+            attribute_to_check.name.to_s.downcase == current_path_entry
           end
 
           if found_attribute && path.present? # Any sub-attributes to check?...

data/lib/scimitar/support/hash_with_indifferent_case_insensitive_access.rb

@@ -0,0 +1,86 @@
+require 'active_support/hash_with_indifferent_access'
+
+class Hash
+
+  # Converts this Hash to an instance of
+  # Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess, which is
+  # a subclass of ActiveSupport::HashWithIndifferentAccess with the addition of
+  # case-insensitive lookup.
+  #
+  # Note that this is more thorough than the ActiveSupport counterpart. It
+  # converts recursively, so that all Hashes to arbitrary depth, including any
+  # hashes inside Arrays, are converted. This is an expensive operation.
+  #
+  def with_indifferent_case_insensitive_access
+    self.class.deep_indifferent_case_insensitive_access(self)
+  end
+
+  # Supports #with_indifferent_case_insensitive_access. Converts the given item
+  # to indifferent, case-insensitive access as a Hash; or converts Array items
+  # if given an Array; or returns the given object.
+  #
+  # Hashes and Arrays at all depths are duplicated as a result.
+  #
+  def self.deep_indifferent_case_insensitive_access(object)
+    if object.is_a?(Hash)
+      new_hash = Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess.new(object)
+      new_hash.each do | key, value |
+        new_hash[key] = deep_indifferent_case_insensitive_access(value)
+      end
+      new_hash
+
+    elsif object.is_a?(Array)
+      object.map do | array_entry |
+        deep_indifferent_case_insensitive_access(array_entry)
+      end
+
+    else
+      object
+
+    end
+  end
+end
+
+module Scimitar
+  module Support
+
+    # A subclass of ActiveSupport::HashWithIndifferentAccess where not only
+    # can Hash keys be queried as Symbols or Strings, but they are looked up
+    # in a case-insensitive fashion too.
+    #
+    # During enumeration, Hash keys will always be returned in whatever case
+    # they were originally set.
+    #
+    class HashWithIndifferentCaseInsensitiveAccess < ActiveSupport::HashWithIndifferentAccess
+      def with_indifferent_case_insensitive_access
+        self
+      end
+
+      private
+
+        if Symbol.method_defined?(:name)
+          def convert_key(key)
+            key.kind_of?(Symbol) ? key.name.downcase : key.downcase
+          end
+        else
+          def convert_key(key)
+            key.kind_of?(Symbol) ? key.to_s.downcase : key.downcase
+          end
+        end
+
+        def update_with_single_argument(other_hash, block)
+          if other_hash.is_a? HashWithIndifferentCaseInsensitiveAccess
+            regular_update(other_hash, &block)
+          else
+            other_hash.to_hash.each_pair do |key, value|
+              if block && key?(key)
+                value = block.call(convert_key(key), self[key], value)
+              end
+              regular_writer(convert_key(key), convert_value(value))
+            end
+          end
+        end
+
+    end
+  end
+end

data/lib/scimitar/version.rb

@@ -3,11 +3,11 @@ module Scimitar
   # Gem version. If this changes, be sure to re-run "bundle install" or
   # "bundle update".
   #
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 
   # Date for VERSION. If this changes, be sure to re-run "bundle install"
   # or "bundle update".
   #
-  DATE = '2021-03-24'
+  DATE = '2021-09-15'
 
 end

data/lib/scimitar.rb

@@ -1,4 +1,5 @@
 require 'scimitar/version'
+require 'scimitar/support/hash_with_indifferent_case_insensitive_access'
 require 'scimitar/engine'
 
 module Scimitar

data/spec/models/scimitar/resources/base_spec.rb

@@ -24,53 +24,78 @@ RSpec.describe Scimitar::Resources::Base do
     end
 
     context '#initialize' do
-      it 'builds the nested type' do
-        resource = CustomResourse.new(name: {
-          givenName: 'John',
-          familyName: 'Smith'
-        })
+      shared_examples 'an initializer' do | force_upper_case: |
+        it 'which builds the nested type' do
+          attributes = {
+            name: {
+              givenName:  'John',
+              familyName: 'Smith'
+            }
+          }
 
-        expect(resource.name.is_a?(Scimitar::ComplexTypes::Name)).to be(true)
-        expect(resource.name.givenName).to eql('John')
-        expect(resource.name.familyName).to eql('Smith')
-      end
+          attributes = spec_helper_hupcase(attributes) if force_upper_case
+          resource   = CustomResourse.new(attributes)
+
+          expect(resource.name.is_a?(Scimitar::ComplexTypes::Name)).to be(true)
+          expect(resource.name.givenName).to eql('John')
+          expect(resource.name.familyName).to eql('Smith')
+        end
 
-      it 'builds an array of nested resources' do
-        resource = CustomResourse.new(names: [
-          {
-            givenName: 'John',
-            familyName: 'Smith'
-          },
-          {
-            givenName: 'Jane',
-            familyName: 'Snow'
+        it 'which builds an array of nested resources' do
+          attributes = {
+            names:[
+              {
+                givenName:  'John',
+                familyName: 'Smith'
+              },
+              {
+                givenName:  'Jane',
+                familyName: 'Snow'
+              }
+            ]
           }
-        ])
-
-        expect(resource.names.is_a?(Array)).to be(true)
-        expect(resource.names.first.is_a?(Scimitar::ComplexTypes::Name)).to be(true)
-        expect(resource.names.first.givenName).to eql('John')
-        expect(resource.names.first.familyName).to eql('Smith')
-        expect(resource.names.second.is_a?(Scimitar::ComplexTypes::Name)).to be(true)
-        expect(resource.names.second.givenName).to eql('Jane')
-        expect(resource.names.second.familyName).to eql('Snow')
-        expect(resource.valid?).to be(true)
-      end
 
-      it 'builds an array of nested resources which is invalid if the hash does not follow the schema of the complex type' do
-        resource = CustomResourse.new(names: [
-          {
-            givenName: 'John',
-            familyName: 123
+          attributes = spec_helper_hupcase(attributes) if force_upper_case
+          resource   = CustomResourse.new(attributes)
+
+          expect(resource.names.is_a?(Array)).to be(true)
+          expect(resource.names.first.is_a?(Scimitar::ComplexTypes::Name)).to be(true)
+          expect(resource.names.first.givenName).to eql('John')
+          expect(resource.names.first.familyName).to eql('Smith')
+          expect(resource.names.second.is_a?(Scimitar::ComplexTypes::Name)).to be(true)
+          expect(resource.names.second.givenName).to eql('Jane')
+          expect(resource.names.second.familyName).to eql('Snow')
+          expect(resource.valid?).to be(true)
+        end
+
+        it 'which builds an array of nested resources which is invalid if the hash does not follow the schema of the complex type' do
+          attributes = {
+            names: [
+              {
+                givenName:  'John',
+                familyName: 123
+              }
+            ]
           }
-        ])
 
-        expect(resource.names.is_a?(Array)).to be(true)
-        expect(resource.names.first.is_a?(Scimitar::ComplexTypes::Name)).to be(true)
-        expect(resource.names.first.givenName).to eql('John')
-        expect(resource.names.first.familyName).to eql(123)
-        expect(resource.valid?).to be(false)
-      end
+          attributes = spec_helper_hupcase(attributes) if force_upper_case
+          resource   = CustomResourse.new(attributes)
+
+          expect(resource.names.is_a?(Array)).to be(true)
+          expect(resource.names.first.is_a?(Scimitar::ComplexTypes::Name)).to be(true)
+          expect(resource.names.first.givenName).to eql('John')
+          expect(resource.names.first.familyName).to eql(123)
+          expect(resource.valid?).to be(false)
+        end
+      end # "shared_examples 'an initializer' do | force_upper_case: |"
+
+      context 'using schema-matched case' do
+        it_behaves_like 'an initializer', force_upper_case: false
+      end # "context 'using schema-matched case' do"
+
+      context 'using upper case' do
+        it_behaves_like 'an initializer', force_upper_case: true
+      end # "context 'using upper case' do"
     end # "context '#initialize' do"
 
     context '#as_json' do
@@ -88,26 +113,51 @@ RSpec.describe Scimitar::Resources::Base do
     end # "context '#as_json' do"
 
     context '.find_attribute' do
-      it 'finds in complex type' do
-        found = CustomResourse.find_attribute('name', 'givenName')
-        expect(found).to be_present
-        expect(found.name).to eql('givenName')
-        expect(found.type).to eql('string')
-      end
+      shared_examples 'a finder' do | force_upper_case: |
+        it 'which finds in complex type' do
+          args = ['name', 'givenName']
+          args.map!(&:upcase) if force_upper_case
 
-      it 'finds in multi-value type, without index' do
-        found = CustomResourse.find_attribute('names', 'givenName')
-        expect(found).to be_present
-        expect(found.name).to eql('givenName')
-        expect(found.type).to eql('string')
-      end
+          found = CustomResourse.find_attribute(*args)
 
-      it 'finds in multi-value type, ignoring index' do
-        found = CustomResourse.find_attribute('names', 42, 'givenName')
-        expect(found).to be_present
-        expect(found.name).to eql('givenName')
-        expect(found.type).to eql('string')
+          expect(found).to be_present
+          expect(found.name).to eql('givenName')
+          expect(found.type).to eql('string')
+        end
+
+        it 'which finds in multi-value type, without index' do
+          args = ['names', 'givenName']
+          args.map!(&:upcase) if force_upper_case
+
+          found = CustomResourse.find_attribute(*args)
+
+          expect(found).to be_present
+          expect(found.name).to eql('givenName')
+          expect(found.type).to eql('string')
+        end
+
+        it 'which finds in multi-value type, ignoring index' do
+          args = if force_upper_case
+            ['NAMES', 42, 'GIVENNAME']
+          else
+            ['names', 42, 'givenName']
+          end
+
+          found = CustomResourse.find_attribute(*args)
+
+          expect(found).to be_present
+          expect(found.name).to eql('givenName')
+          expect(found.type).to eql('string')
+        end # "shared_examples 'a finder' do | force_upper_case: |"
       end
+
+      context 'using schema-matched case' do
+        it_behaves_like 'a finder', force_upper_case: false
+      end # "context 'using schema-matched case' do"
+
+      context 'using upper case' do
+        it_behaves_like 'a finder', force_upper_case: true
+      end # "context 'using upper case' do"
     end # "context '.find_attribute' do"
   end # "context 'basic operation' do"