scimitar 1.11.0 → 2.0.0

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

@@ -81,102 +81,6 @@ RSpec.describe Scimitar::Resources::Mixin do
     include Scimitar::Resources::Mixin
   end
 
-  # A simple schema containing two attributes that looks very like complex
-  # type "name", except shorter and with "familyName" never returned.
-  #
-  NestedReturnedNeverTestNameSchema = Class.new(Scimitar::Schema::Base) do
-    def self.id
-      'nested-returned-never-name-id'
-    end
-
-    def self.scim_attributes
-      @scim_attributes ||= [
-        Scimitar::Schema::Attribute.new(name: 'familyName', type: 'string', required: true, returned: 'never'),
-        Scimitar::Schema::Attribute.new(name: 'givenName',  type: 'string', required: true)
-      ]
-    end
-  end
-
-  # A complex type that uses the above schema, giving us the ability to define
-  # an attribute using this complex type, with therefore the *nested* attribute
-  # "familyName" being never returned.
-  #
-  NestedReturnedNeverTestNameType = Class.new(Scimitar::ComplexTypes::Base) do
-    set_schema NestedReturnedNeverTestNameSchema
-  end
-
-  # A test schema that uses the above type, the standard name type (but that
-  # *entire* top-level attribute is never returned) and a simple String item.
-  #
-  NestedReturnedNeverTestSchema = Class.new(Scimitar::Schema::Base) do
-    def self.id
-      'nested-returned-never-id'
-    end
-
-    def self.scim_attributes
-      [
-        Scimitar::Schema::Attribute.new(
-          name: 'name', complexType: NestedReturnedNeverTestNameType
-        ),
-        Scimitar::Schema::Attribute.new(
-          name: 'privateName', complexType: Scimitar::ComplexTypes::Name, returned: 'never'
-        ),
-        Scimitar::Schema::Attribute.new(
-          name: 'simpleName',  type: 'string'
-        )
-      ]
-    end
-  end
-
-  # Define a resource that is based upon the above schema.
-  #
-  NestedReturnedNeverTestResourse = Class.new(Scimitar::Resources::Base) do
-    set_schema NestedReturnedNeverTestSchema
-  end
-
-  # Create a testable model that is our internal representation of the above
-  # resource.
-  #
-  class NestedReturnedNeverTest
-    include ActiveModel::Model
-
-    def self.scim_resource_type
-      return NestedReturnedNeverTestResourse
-    end
-
-    attr_accessor :given_name,
-                  :last_name,
-                  :private_given_name,
-                  :private_last_name,
-                  :simple_name
-
-    def self.scim_attributes_map
-      return {
-        name: {
-          givenName:  :given_name,
-          familyName: :last_name
-        },
-
-        privateName: {
-          givenName:  :private_given_name,
-          familyName: :private_last_name
-        },
-
-        simpleName: :simple_name
-      }
-    end
-
-    def self.scim_mutable_attributes
-      return nil
-    end
-
-    def self.scim_queryable_attributes
-      return nil
-    end
-
-    include Scimitar::Resources::Mixin
-  end
-
   # ===========================================================================
   # Errant class definitions
   # ===========================================================================
@@ -255,127 +159,41 @@ RSpec.describe Scimitar::Resources::Mixin do
     # =========================================================================
 
     context '#to_scim' do
-      context 'with list of requested attributes' do
-        it 'compiles instance attribute values into a SCIM representation, including only the requested attributes' do
-          uuid                        = SecureRandom.uuid
-
-          instance                    = MockUser.new
-          instance.primary_key        = uuid
-          instance.scim_uid           = 'AA02984'
-          instance.username           = 'foo'
-          instance.password           = 'correcthorsebatterystaple'
-          instance.first_name         = 'Foo'
-          instance.last_name          = 'Bar'
-          instance.work_email_address = 'foo.bar@test.com'
-          instance.home_email_address = nil
-          instance.work_phone_number  = '+642201234567'
-          instance.organization       = 'SOMEORG'
-
-          g1 = MockGroup.create!(display_name: 'Group 1')
-          g2 = MockGroup.create!(display_name: 'Group 2')
-          g3 = MockGroup.create!(display_name: 'Group 3')
-
-          g1.mock_users << instance
-          g3.mock_users << instance
-
-          scim = instance.to_scim(location: "https://test.com/mock_users/#{uuid}", include_attributes: %w[id userName name groups.display groups.value organization])
-          json = scim.to_json()
-          hash = JSON.parse(json)
-
-          expect(hash).to eql({
-            'id'          => uuid,
-            'userName'    => 'foo',
-            'name'        => {'givenName'=>'Foo', 'familyName'=>'Bar'},
-            'groups'      => [{'display'=>g1.display_name, 'value'=>g1.id.to_s}, {'display'=>g3.display_name, 'value'=>g3.id.to_s}],
-            'meta'        => {'location'=>"https://test.com/mock_users/#{uuid}", 'resourceType'=>'User'},
-            'schemas'     => [
-              'urn:ietf:params:scim:schemas:core:2.0:User',
-              'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User',
-              'urn:ietf:params:scim:schemas:extension:manager:1.0:User',
-            ],
-            'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User' => {
-              'organization' => 'SOMEORG',
-            },
-            'urn:ietf:params:scim:schemas:extension:manager:1.0:User' => {},
-          })
-        end
-      end # "context 'with list of requested attributes' do"
-
-      context 'with a UUID, renamed primary key column' do
-        it 'compiles instance attribute values into a SCIM representation, but omits do-not-return fields' do
-          uuid                        = SecureRandom.uuid
-
-          instance                    = MockUser.new
-          instance.primary_key        = uuid
-          instance.scim_uid           = 'AA02984'
-          instance.username           = 'foo'
-          instance.password           = 'correcthorsebatterystaple'
-          instance.first_name         = 'Foo'
-          instance.last_name          = 'Bar'
-          instance.work_email_address = 'foo.bar@test.com'
-          instance.home_email_address = nil
-          instance.work_phone_number  = '+642201234567'
-          instance.organization       = 'SOMEORG'
-
-          g1 = MockGroup.create!(display_name: 'Group 1')
-          g2 = MockGroup.create!(display_name: 'Group 2')
-          g3 = MockGroup.create!(display_name: 'Group 3')
-
-          g1.mock_users << instance
-          g3.mock_users << instance
-
-          scim = instance.to_scim(location: "https://test.com/mock_users/#{uuid}")
-          json = scim.to_json()
-          hash = JSON.parse(json)
-
-          expect(hash).to eql({
-            'userName'    => 'foo',
-            'name'        => {'givenName'=>'Foo', 'familyName'=>'Bar'},
-            'active'      => true,
-            'emails'      => [{'type'=>'work', 'primary'=>true, 'value'=>'foo.bar@test.com'}, {"primary"=>false, "type"=>"home", "value"=>nil}],
-            'phoneNumbers'=> [{'type'=>'work', 'primary'=>false, 'value'=>'+642201234567'}],
-            'id'          => uuid,
-            'externalId'  => 'AA02984',
-            'groups'      => [{'display'=>g1.display_name, 'value'=>g1.id.to_s}, {'display'=>g3.display_name, 'value'=>g3.id.to_s}],
-            'meta'        => {'location'=>"https://test.com/mock_users/#{uuid}", 'resourceType'=>'User'},
-            'schemas'     => [
-              'urn:ietf:params:scim:schemas:core:2.0:User',
-              'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User',
-              'urn:ietf:params:scim:schemas:extension:manager:1.0:User',
-            ],
-            'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User' => {
-              'organization' => 'SOMEORG',
-              'department'   => nil,
-              'primaryEmail' => instance.work_email_address,
-            },
-            'urn:ietf:params:scim:schemas:extension:manager:1.0:User' => {
-              'manager' => nil
-            },
-          })
-        end
-      end # "context 'with a UUID, renamed primary key column' do"
-
-      context 'with an integer, conventionally named primary key column' do
-        it 'compiles instance attribute values into a SCIM representation' do
-          instance              = MockGroup.new
-          instance.id           = 42
-          instance.scim_uid     = 'GG02984'
-          instance.display_name = 'Some group'
-
-          scim = instance.to_scim(location: 'https://test.com/mock_groups/42')
-          json = scim.to_json()
-          hash = JSON.parse(json)
-
-          expect(hash).to eql({
-            'displayName' => 'Some group',
-            'id'          => '42', # Note, String
-            'externalId'  => 'GG02984',
-            'members'     => [],
-            'meta'        => {'location'=>'https://test.com/mock_groups/42', 'resourceType'=>'Group'},
-            'schemas'     => ['urn:ietf:params:scim:schemas:core:2.0:Group']
-          })
-        end
-      end # "context 'with an integer, conventionally named primary key column' do"
+      it 'compiles instance attribute values into a SCIM representation' do
+        instance                    = MockUser.new
+        instance.id                 = 42
+        instance.scim_uid           = 'AA02984'
+        instance.username           = 'foo'
+        instance.first_name         = 'Foo'
+        instance.last_name          = 'Bar'
+        instance.work_email_address = 'foo.bar@test.com'
+        instance.home_email_address = nil
+        instance.work_phone_number  = '+642201234567'
+
+        g1 = MockGroup.create!(display_name: 'Group 1')
+        g2 = MockGroup.create!(display_name: 'Group 2')
+        g3 = MockGroup.create!(display_name: 'Group 3')
+
+        g1.mock_users << instance
+        g3.mock_users << instance
+
+        scim = instance.to_scim(location: 'https://test.com/mock_users/42')
+        json = scim.to_json()
+        hash = JSON.parse(json)
+
+        expect(hash).to eql({
+          'userName'    => 'foo',
+          'name'        => {'givenName'=>'Foo', 'familyName'=>'Bar'},
+          'active'      => true,
+          'emails'      => [{'type'=>'work', 'primary'=>true, 'value'=>'foo.bar@test.com'}, {"primary"=>false, "type"=>"home", "value"=>nil}],
+          'phoneNumbers'=> [{'type'=>'work', 'primary'=>false, 'value'=>'+642201234567'}],
+          'id'          => '42', # Note, String
+          'externalId'  => 'AA02984',
+          'groups'      => [{'display'=>g1.display_name, 'value'=>g1.id.to_s}, {'display'=>g3.display_name, 'value'=>g3.id.to_s}],
+          'meta'        => {'location'=>'https://test.com/mock_users/42', 'resourceType'=>'User'},
+          'schemas'     => ['urn:ietf:params:scim:schemas:core:2.0:User']
+        })
+      end
 
       context 'with optional timestamps' do
         context 'creation only' do
@@ -474,13 +292,7 @@ RSpec.describe Scimitar::Resources::Mixin do
               ],
 
               'meta'    => {'location'=>'https://test.com/static_map_test', 'resourceType'=>'User'},
-              'schemas' => [
-                'urn:ietf:params:scim:schemas:core:2.0:User',
-                'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User',
-                'urn:ietf:params:scim:schemas:extension:manager:1.0:User',
-              ],
-              'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User' => {},
-              'urn:ietf:params:scim:schemas:extension:manager:1.0:User' => {},
+              'schemas' => ['urn:ietf:params:scim:schemas:core:2.0:User']
             })
           end
         end # "context 'using static mappings' do"
@@ -507,42 +319,12 @@ RSpec.describe Scimitar::Resources::Mixin do
               ],
 
               'meta'    => {'location'=>'https://test.com/dynamic_map_test', 'resourceType'=>'User'},
-              'schemas' => [
-                'urn:ietf:params:scim:schemas:core:2.0:User',
-                'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User',
-                'urn:ietf:params:scim:schemas:extension:manager:1.0:User',
-              ],
-              'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User' => {},
-              'urn:ietf:params:scim:schemas:extension:manager:1.0:User' => {},
+              'schemas' => ['urn:ietf:params:scim:schemas:core:2.0:User']
             })
           end
         end # "context 'using dynamic lists' do"
       end # "context 'with arrays' do"
 
-      context 'with "returned: \'never\' fields' do
-        it 'hides appropriate top-level and nested attributes' do
-          instance = NestedReturnedNeverTest.new(
-            given_name:          'One',
-            last_name:           'Two',
-            private_given_name:  'Three',
-            private_last_name:   'Four',
-            simple_name:         'Five'
-          )
-
-          scim = instance.to_scim(location: 'https://test.com/never_retutrned_test')
-          json = scim.to_json()
-          hash = JSON.parse(json)
-
-          expect(hash).to eql({
-            'name'       => { 'givenName' => 'One' },
-            'simpleName' => 'Five',
-
-            'meta'    => {'location'=>'https://test.com/never_retutrned_test', 'resourceType'=>'NestedReturnedNeverTestResourse'},
-            'schemas' => ['nested-returned-never-id']
-          })
-        end
-      end # "context 'with "returned: \'never\' fields' do"
-
       context 'with bad definitions' do
         it 'complains about non-Hash entries in mapping Arrays' do
           expect(StaticMapTest).to receive(:scim_attributes_map).and_return({
@@ -586,7 +368,6 @@ RSpec.describe Scimitar::Resources::Mixin do
           it 'ignoring read-only lists' do
             hash = {
               'userName'     => 'foo',
-              'password'     => 'staplebatteryhorsecorrect',
               'name'         => {'givenName' => 'Foo', 'familyName' => 'Bar'},
               'active'       => true,
               'emails'       => [{'type' => 'work',  'primary' => true,  'value' => 'foo.bar@test.com'}],
@@ -595,12 +376,7 @@ RSpec.describe Scimitar::Resources::Mixin do
               'id'           => '42', # Note, String
               'externalId'   => 'AA02984',
               'meta'         => {'location' => 'https://test.com/mock_users/42', 'resourceType' => 'User'},
-              'schemas'      => ['urn:ietf:params:scim:schemas:core:2.0:User', 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User'],
-
-              'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User' => {
-                'organization' => 'SOMEORG',
-                'DEPARTMENT'   => 'SOMEDPT'
-              }
+              'schemas'      => ['urn:ietf:params:scim:schemas:core:2.0:User']
             }
 
             hash = spec_helper_hupcase(hash) if force_upper_case
@@ -611,14 +387,11 @@ RSpec.describe Scimitar::Resources::Mixin do
 
             expect(instance.scim_uid          ).to eql('AA02984')
             expect(instance.username          ).to eql('foo')
-            expect(instance.password          ).to eql('staplebatteryhorsecorrect')
             expect(instance.first_name        ).to eql('Foo')
             expect(instance.last_name         ).to eql('Bar')
             expect(instance.work_email_address).to eql('foo.bar@test.com')
             expect(instance.home_email_address).to be_nil
             expect(instance.work_phone_number ).to eql('+642201234567')
-            expect(instance.organization      ).to eql('SOMEORG')
-            expect(instance.department        ).to eql('SOMEDPT')
           end
 
           it 'honouring read-write lists' do
@@ -632,8 +405,8 @@ RSpec.describe Scimitar::Resources::Mixin do
               'displayName' => 'Foo Group',
               'members'     => [
                 {'type' => 'Group', 'value' => g1.id.to_s},
-                {'type' => 'User',  'value' => u1.primary_key.to_s},
-                {'type' => 'User',  'value' => u3.primary_key.to_s}
+                {'type' => 'User',  'value' => u1.id.to_s},
+                {'type' => 'User',  'value' => u3.id.to_s}
               ],
               'externalId'  => 'GG01536',
               'meta'        => {'location'=>'https://test.com/mock_groups/1', 'resourceType'=>'Group'},
@@ -680,10 +453,8 @@ RSpec.describe Scimitar::Resources::Mixin do
       end # "context 'using upper case' do"
 
       it 'clears things not present in input' do
-        uuid                        = SecureRandom.uuid
-
         instance                    = MockUser.new
-        instance.primary_key        = uuid
+        instance.id                 = 42
         instance.scim_uid           = 'AA02984'
         instance.username           = 'foo'
         instance.first_name         = 'Foo'
@@ -694,7 +465,7 @@ RSpec.describe Scimitar::Resources::Mixin do
 
         instance.from_scim!(scim_hash: {})
 
-        expect(instance.primary_key       ).to eql(uuid)
+        expect(instance.id                ).to eql(42)
         expect(instance.scim_uid          ).to be_nil
         expect(instance.username          ).to be_nil
         expect(instance.first_name        ).to be_nil
@@ -883,8 +654,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'add',
                   path:          path,
                   value:         'foo',
-                  altering_hash: scim_hash,
-                  with_attr_map: { userName: :user_name }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['userName']).to eql('foo')
@@ -899,30 +669,13 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'add',
                   path:          path,
                   value:         'Baz',
-                  altering_hash: scim_hash,
-                  with_attr_map: { name: { givenName: :first_name, familyName: :last_name } }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['name']['givenName' ]).to eql('Baz')
                 expect(scim_hash['name']['familyName']).to eql('Bar')
               end
 
-              it 'with schema extensions: overwrites' do
-                path      = [ 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User', 'organization' ]
-                scim_hash = { 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User' => { 'organization' => 'SOMEORG' } }.with_indifferent_case_insensitive_access()
-
-                @instance.send(
-                  :from_patch_backend!,
-                  nature:        'add',
-                  path:          path,
-                  value:         'OTHERORG',
-                  altering_hash: scim_hash,
-                  with_attr_map: { organization: :org_name }
-                )
-
-                expect(scim_hash['urn:ietf:params:scim:schemas:extension:enterprise:2.0:User']['organization' ]).to eql('OTHERORG')
-              end
-
               # For 'add', filter at end-of-path is nonsensical and not
               # supported by spec or Scimitar; we only test mid-path filters.
               #
@@ -947,13 +700,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'add',
                     path:          path,
                     value:         'added_over_original@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
@@ -979,13 +726,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'add',
                     path:          path,
                     value:         'added_over_original@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
@@ -1012,13 +753,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'add',
                     path:          path,
                     value:         'added_over_original@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('added_over_original@test.com')
@@ -1042,13 +777,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'add',
                   path:          path,
                   value:         [ { 'type' => 'work', 'value' => 'work@test.com' } ], # NOTE - to-add value is an Array (and must be)
-                  altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['emails'].size).to eql(2)
@@ -1096,12 +825,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'add',
                     path:          ['root'],
                     value:         {'members' => [{'value' => '3'}]},
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      members: [
-                        { list: :members, using: { value: :id } }
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['root']['members']).to match_array([{'value' => '1'}, {'value' => '2'}, {'value' => '3'}])
@@ -1119,8 +843,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'add',
                   path:          path,
                   value:         'foo',
-                  altering_hash: scim_hash,
-                  with_attr_map: { userName: :user_name }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['userName']).to eql('foo')
@@ -1135,29 +858,12 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'add',
                   path:          path,
                   value:         'Baz',
-                  altering_hash: scim_hash,
-                  with_attr_map: { name: { givenName: :first_name, familyName: :last_name } }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['name']['givenName']).to eql('Baz')
               end
 
-              it 'with schema extensions: adds' do
-                path      = [ 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User', 'organization' ]
-                scim_hash = {}.with_indifferent_case_insensitive_access()
-
-                @instance.send(
-                  :from_patch_backend!,
-                  nature:        'add',
-                  path:          path,
-                  value:         'SOMEORG',
-                  altering_hash: scim_hash,
-                  with_attr_map: { organization: :org_name }
-                )
-
-                expect(scim_hash['urn:ietf:params:scim:schemas:extension:enterprise:2.0:User']['organization' ]).to eql('SOMEORG')
-              end
-
               context 'with filter mid-path: adds' do
                 it 'by string match' do
                   path      = [ 'emails[type eq "work"]', 'value' ]
@@ -1178,13 +884,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'add',
                     path:          path,
                     value:         'added@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
@@ -1209,13 +909,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'add',
                     path:          path,
                     value:         'added@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
@@ -1231,13 +925,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'add',
                     path:          path,
                     value:         'added@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('added@test.com')
@@ -1261,13 +949,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'add',
                     path:          path,
                     value:         'added@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('added@test.com')
@@ -1284,13 +966,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'add',
                   path:          path,
                   value:         [ { 'type' => 'work', 'value' => 'work@test.com' } ], # NOTE - to-add value is an Array (and must be)
-                  altering_hash: scim_hash,
-                  with_attr_map: {
-                    emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                      { match: 'type', with: 'work', using: { value: :work_email } },
-                    ]
-                  }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['emails'].size).to eql(1)
@@ -1306,7 +982,7 @@ RSpec.describe Scimitar::Resources::Mixin do
           #
           context 'remove' do
             context 'when prior value already exists' do
-              it 'simple value: clears to "nil" in order to remove' do
+              it 'simple value: removes' do
                 path      = [ 'userName' ]
                 scim_hash = { 'userName' => 'bar' }.with_indifferent_case_insensitive_access()
 
@@ -1315,14 +991,13 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'remove',
                   path:          path,
                   value:         nil,
-                  altering_hash: scim_hash,
-                  with_attr_map: { userName: :user_name }
+                  altering_hash: scim_hash
                 )
 
-                expect(scim_hash).to eql({ 'userName' => nil })
+                expect(scim_hash).to be_empty
               end
 
-              it 'nested simple value: clears to "nil" in order to remove' do
+              it 'nested simple value: removes' do
                 path      = [ 'name', 'givenName' ]
                 scim_hash = { 'name' => { 'givenName' => 'Foo', 'familyName' => 'Bar' } }.with_indifferent_case_insensitive_access()
 
@@ -1331,15 +1006,15 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'remove',
                   path:          path,
                   value:         nil,
-                  altering_hash: scim_hash,
-                  with_attr_map: { name: { givenName: :first_name, familyName: :last_name } }
+                  altering_hash: scim_hash
                 )
 
-                expect(scim_hash).to eql({ 'name' => { 'givenName' => nil, 'familyName' => 'Bar' } })
+                expect(scim_hash['name']).to_not have_key('givenName')
+                expect(scim_hash['name']['familyName']).to eql('Bar')
               end
 
               context 'with filter mid-path' do
-                it 'by string match: clears to "nil" in order to remove' do
+                it 'by string match: removes' do
                   path      = [ 'emails[type eq "work"]', 'value' ]
                   scim_hash = {
                     'emails' => [
@@ -1359,30 +1034,14 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'remove',
                     path:          path,
                     value:         nil,
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
-                  expect(scim_hash).to eql({
-                    'emails' => [
-                      {
-                        'type' => 'home',
-                        'value' => 'home@test.com'
-                      },
-                      {
-                        'type' => 'work',
-                        'value' => nil
-                      }
-                    ]
-                  })
+                  expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
+                  expect(scim_hash['emails'][1]).to_not have_key('value')
                 end
 
-                it 'by boolean match: clears to "nil" in order to remove' do
+                it 'by boolean match: removes' do
                   path      = [ 'emails[primary eq true]', 'value' ]
                   scim_hash = {
                     'emails' => [
@@ -1401,29 +1060,14 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'remove',
                     path:          path,
                     value:         nil,
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
-                  expect(scim_hash).to eql({
-                    'emails' => [
-                      {
-                        'value' => 'home@test.com'
-                      },
-                      {
-                        'value' => nil,
-                        'primary' => true
-                      }
-                    ]
-                  })
+                  expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
+                  expect(scim_hash['emails'][1]).to_not have_key('value')
                 end
 
-                it 'multiple matches: clears all to "nil" in order to remove' do
+                it 'multiple matches: removes all' do
                   path      = [ 'emails[type eq "work"]', 'value' ]
                   scim_hash = {
                     'emails' => [
@@ -1434,11 +1078,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                       {
                         'type' => 'work',
                         'value' => 'work_2@test.com'
-                      },
-                      {
-                        'type' => 'home',
-                        'value' => 'home@test.com'
-                      },
+                      }
                     ]
                   }.with_indifferent_case_insensitive_access()
 
@@ -1447,36 +1087,16 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'remove',
                     path:          path,
                     value:         nil,
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
-                  expect(scim_hash).to eql({
-                    'emails' => [
-                      {
-                        'type' => 'work',
-                        'value' => nil
-                      },
-                      {
-                        'type' => 'work',
-                        'value' => nil
-                      },
-                      {
-                        'type' => 'home',
-                        'value' => 'home@test.com'
-                      },
-                    ]
-                  })
+                  expect(scim_hash['emails'][0]).to_not have_key('value')
+                  expect(scim_hash['emails'][1]).to_not have_key('value')
                 end
               end # "context 'with filter mid-path' do"
 
               context 'with filter at end of path' do
-                it 'by string match: clears to "nil" in order to remove' do
+                it 'by string match: removes entire matching array entry' do
                   path      = [ 'emails[type eq "work"]' ]
                   scim_hash = {
                     'emails' => [
@@ -1496,39 +1116,23 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'remove',
                     path:          path,
                     value:         nil,
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
-                  expect(scim_hash).to eql({
-                    'emails' => [
-                      {
-                        'type' => 'home',
-                        'value' => 'home@test.com'
-                      },
-                      {
-                        'type' => 'work',
-                        'value' => nil
-                      }
-                    ]
-                  })
+                  expect(scim_hash['emails'].size).to eql(1)
+                  expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
                 end
 
-                it 'by boolean match: clears to "nil" in order to remove' do
+                it 'by boolean match: removes entire matching array entry' do
                   path      = [ 'emails[primary eq true]' ]
                   scim_hash = {
                     'emails' => [
                       {
-                        'value' => 'home@test.com',
-                        'primary' => true
+                        'value' => 'home@test.com'
                       },
                       {
-                        'value' => 'work@test.com'
+                        'value' => 'work@test.com',
+                        'primary' => true
                       }
                     ]
                   }.with_indifferent_case_insensitive_access()
@@ -1538,29 +1142,14 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'remove',
                     path:          path,
                     value:         nil,
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
-                  expect(scim_hash).to eql({
-                    'emails' => [
-                      {
-                        'value' => nil,
-                        'primary' => true
-                      },
-                      {
-                        'value' => 'work@test.com'
-                      }
-                    ]
-                  })
+                  expect(scim_hash['emails'].size).to eql(1)
+                  expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
                 end
 
-                it 'multiple matches: clears all to "nil" in order to remove' do
+                it 'multiple matches: removes all matching array entries' do
                   path      = [ 'emails[type eq "work"]' ]
                   scim_hash = {
                     'emails' => [
@@ -1584,45 +1173,21 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'remove',
                     path:          path,
                     value:         nil,
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
-                  expect(scim_hash).to eql({
-                    'emails' => [
-                      {
-                        'type' => 'work',
-                        'value' => nil
-                      },
-                      {
-                        'type' => 'work',
-                        'value' => nil
-                      },
-                      {
-                        'type' => 'home',
-                        'value' => 'home@test.com'
-                      },
-                    ]
-                  })
+                  expect(scim_hash['emails'].size).to eql(1)
+                  expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
                 end
               end # "context 'with filter at end of path' do"
 
-              it 'whole array: clears mapped values to "nil" to remove them' do
+              it 'whole array: removes' do
                 path      = [ 'emails' ]
                 scim_hash = {
                   'emails' => [
                     {
                       'type' => 'home',
                       'value' => 'home@test.com'
-                    },
-                    {
-                      'type' => 'work',
-                      'value' => 'work@test.com'
                     }
                   ]
                 }.with_indifferent_case_insensitive_access()
@@ -1632,741 +1197,11 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'remove',
                   path:          path,
                   value:         nil,
-                  altering_hash: scim_hash,
-                  with_attr_map: {
-                    emails: [
-                      { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                      { match: 'type', with: 'work', using: { value: :work_email } },
-                    ]
-                  }
+                  altering_hash: scim_hash
                 )
 
-                expect(scim_hash).to eql({
-                  'emails' => [
-                    {
-                      'type' => 'home',
-                      'value' => nil
-                    },
-                    {
-                      'type' => 'work',
-                      'value' => nil
-                    }
-                  ]
-                })
+                expect(scim_hash).to_not have_key('emails')
               end
-
-              # What we expect:
-              #
-              # https://tools.ietf.org/html/rfc7644#section-3.5.2.2
-              # https://docs.snowflake.com/en/user-guide/scim-intro.html#patch-scim-v2-groups-id
-              #
-              # ...vs accounting for the unusual payloads we sometimes get,
-              # tested here.
-              #
-              context 'special cases' do
-
-                # https://learn.microsoft.com/en-us/azure/active-directory/app-provisioning/use-scim-to-provision-users-and-groups#update-group-remove-members
-                #
-                context 'Microsoft-style payload' do
-                  context 'removing a user from a group' do
-                    it 'removes identified user' do
-                      path      = [ 'members' ]
-                      value     = [ { '$ref' => nil, 'value' => 'f648f8d5ea4e4cd38e9c' } ]
-                      scim_hash = {
-                        'displayname' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => '50ca93d04ab0c2de4772',
-                            'display' => 'Ingrid Smith',
-                            'type'    => 'User'
-                          },
-                          {
-                            'value'   => 'f648f8d5ea4e4cd38e9c',
-                            'display' => 'Fred Smith',
-                            'type'    => 'User'
-                          },
-                          {
-                            'value'   => 'a774d480e8112101375b',
-                            'display' => 'Taylor Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          members: [
-                            { list: :members, using: { value: :id, display: :full_name, type: 'User' } }
-                          ]
-                        }
-                      )
-
-                      expect(scim_hash).to eql({
-                        'displayname' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => '50ca93d04ab0c2de4772',
-                            'display' => 'Ingrid Smith',
-                            'type'    => 'User'
-                          },
-                          {
-                            'value'   => 'a774d480e8112101375b',
-                            'display' => 'Taylor Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      })
-                    end
-
-                    it 'removes multiple identified users' do
-                      path      = [ 'members' ]
-                      value     = [
-                        { '$ref' => nil, 'value' => 'f648f8d5ea4e4cd38e9c' },
-                        { '$ref' => nil, 'value' => '50ca93d04ab0c2de4772' }
-                      ]
-                      scim_hash = {
-                        'displayname' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => '50ca93d04ab0c2de4772',
-                            'display' => 'Ingrid Smith',
-                            'type'    => 'User'
-                          },
-                          {
-                            'value'   => 'f648f8d5ea4e4cd38e9c',
-                            'display' => 'Fred Smith',
-                            'type'    => 'User'
-                          },
-                          {
-                            'value'   => 'a774d480e8112101375b',
-                            'display' => 'Taylor Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          members: [
-                            { list: :members, using: { value: :id, display: :full_name, type: 'User' } }
-                          ]
-                        }
-                      )
-
-                      expect(scim_hash).to eql({
-                        'displayname' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => 'a774d480e8112101375b',
-                            'display' => 'Taylor Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      })
-                    end
-
-                    it 'removes all users individually without error' do
-                      path      = [ 'members' ]
-                      value     = [ { '$ref' => nil, 'value' => 'f648f8d5ea4e4cd38e9c' } ]
-                      scim_hash = {
-                        'displayname' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => 'f648f8d5ea4e4cd38e9c',
-                            'display' => 'Fred Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          members: [
-                            { list: :members, using: { value: :id, display: :full_name, type: 'User' } }
-                          ]
-                        }
-                      )
-
-                      expect(scim_hash).to eql({
-                        'displayname' => 'Mock group',
-                        'members'     => []
-                      })
-                    end
-
-                    it 'can match on multiple attributes' do
-                      path      = [ 'members' ]
-                      value     = [ { '$ref' => nil, 'value' => 'f648f8d5ea4e4cd38e9c', 'type' => 'User' } ]
-                      scim_hash = {
-                        'displayname' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => 'f648f8d5ea4e4cd38e9c',
-                            'display' => 'Fred Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          members: [
-                            { list: :members, using: { value: :id, display: :full_name, type: 'User' } }
-                          ]
-                        }
-                      )
-
-                      expect(scim_hash).to eql({
-                        'displayname' => 'Mock group',
-                        'members'     => []
-                      })
-                    end
-
-                    it 'ignores unrecognised users' do
-                      path      = [ 'members' ]
-                      value     = [ { '$ref' => nil, 'value' => '11b054a9c85216ed9356' } ]
-                      scim_hash = {
-                        'displayname' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => 'f648f8d5ea4e4cd38e9c',
-                            'display' => 'Fred Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          members: [
-                            { list: :members, using: { value: :id, display: :full_name, type: 'User' } }
-                          ]
-                        }
-                      )
-
-                      # The 'value' mismatched, so the user was not removed.
-                      #
-                      expect(scim_hash).to eql({
-                        'displayname' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => 'f648f8d5ea4e4cd38e9c',
-                            'display' => 'Fred Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      })
-                    end
-
-                    it 'ignores a mismatch on (for example) "type"' do
-                      path      = [ 'members' ]
-                      value     = [ { '$ref' => nil, 'value' => 'f648f8d5ea4e4cd38e9c', 'type' => 'Group' } ]
-                      scim_hash = {
-                        'displayname' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => 'f648f8d5ea4e4cd38e9c',
-                            'display' => 'Fred Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          members: [
-                            { list: :members, using: { value: :id, display: :full_name, type: 'User' } }
-                          ]
-                        }
-                      )
-
-                      # Type 'Group' mismatches 'User', so the user was not
-                      # removed.
-                      #
-                      expect(scim_hash).to eql({
-                        'displayname' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => 'f648f8d5ea4e4cd38e9c',
-                            'display' => 'Fred Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      })
-                    end
-
-                    it 'matches keys case-insensitive (but preserves case in response)' do
-                      path      = [ 'members' ]
-                      value     = [ { '$ref' => nil, 'VALUe' => 'f648f8d5ea4e4cd38e9c' } ]
-                      scim_hash = {
-                        'displayname' => 'Mock group',
-                        'memBERS'     => [
-                          {
-                            'vaLUe'   => 'f648f8d5ea4e4cd38e9c',
-                            'display' => 'Fred Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          members: [
-                            { list: :members, using: { value: :id, display: :full_name, type: 'User' } }
-                          ]
-                        }
-                      )
-
-                      expect(scim_hash).to eql({
-                        'displayname' => 'Mock group',
-                        'memBERS'     => []
-                      })
-                    end
-
-                    it 'matches values case-sensitive' do
-                      path      = [ 'members' ]
-                      value     = [ { '$ref' => nil, 'value' => 'f648f8d5ea4e4cd38e9c', 'type' => 'USER' } ]
-                      scim_hash = {
-                        'displayName' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => 'f648f8d5ea4e4cd38e9c',
-                            'display' => 'Fred Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          members: [
-                            { list: :members, using: { value: :id, display: :full_name, type: 'User' } }
-                          ]
-                        }
-                      )
-
-                      # USER mismatches User, so the user was not removed.
-                      #
-                      expect(scim_hash).to eql({
-                        'displayName' => 'Mock group',
-                        'members'     => [
-                          {
-                            'value'   => 'f648f8d5ea4e4cd38e9c',
-                            'display' => 'Fred Smith',
-                            'type'    => 'User'
-                          }
-                        ]
-                      })
-                    end
-                  end # "context 'removing a user from a group' do"
-
-                  context 'generic use' do
-                    it 'clears static map matched items to "nil" in order to remove' do
-                      path      = [ 'emails' ]
-                      value     = [ { 'type' => 'work' } ]
-                      scim_hash = {
-                        'emails' => [
-                          {
-                            'type' => 'home',
-                            'value' => 'home@test.com'
-                          },
-                          {
-                            'type' => 'work',
-                            'value' => 'work@test.com'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          emails: [
-                            { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                            { match: 'type', with: 'work', using: { value: :work_email } },
-                          ]
-                        }
-                      )
-
-                      expect(scim_hash).to eql({
-                        'emails' => [
-                          {
-                            'type' => 'home',
-                            'value' => 'home@test.com'
-                          },
-                          {
-                            'type' => 'work',
-                            'value' => nil
-                          }
-                        ]
-                      })
-                    end
-
-                    it 'ignores unmatched items' do
-                      path      = [ 'emails' ]
-                      value     = [ { 'type' => 'missing' } ]
-                      scim_hash = {
-                        'emails' => [
-                          {
-                            'type' => 'home',
-                            'value' => 'home@test.com'
-                          },
-                          {
-                            'type' => 'work',
-                            'value' => 'work@test.com'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          emails: [
-                            { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                            { match: 'type', with: 'work', using: { value: :work_email } },
-                          ]
-                        }
-                      )
-
-                      expect(scim_hash).to eql({
-                        'emails' => [
-                          {
-                            'type' => 'home',
-                            'value' => 'home@test.com'
-                          },
-                          {
-                            'type' => 'work',
-                            'value' => 'work@test.com'
-                          }
-                        ]
-                      })
-                    end
-
-                    it 'compares string forms' do
-                      path      = [ 'test' ]
-                      value     = [
-                        { 'active' => true,    'value' => '12' },
-                        { 'active' => 'false', 'value' => 42   }
-                      ]
-                      scim_hash = {
-                        'test' => [
-                          {
-                            'active' => 'true',
-                            'value' => 12
-                          },
-                          {
-                            'active' => false,
-                            'value' => '42'
-                          },
-                          {
-                            'active' => 'hello',
-                            'value'  => 'world'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          test: [
-                            {
-                              list: :test,
-                              using: {
-                                active: :active,
-                                value:  :value
-                              }
-                            }
-                          ]
-                        }
-                      )
-
-                      expect(scim_hash).to eql({
-                        'test' => [
-                          {
-                            'active' => 'hello',
-                            'value'  => 'world'
-                          }
-                        ]
-                      })
-                    end
-
-                    it 'handles a singular to-remove value rather than an array' do
-                      path      = [ 'emails' ]
-                      value     = { 'type' => 'work' }
-                      scim_hash = {
-                        'emails' => [
-                          {
-                            'type' => 'home',
-                            'value' => 'home@test.com'
-                          },
-                          {
-                            'type' => 'work',
-                            'value' => 'work@test.com'
-                          }
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          emails: [
-                            { match: 'type', with: 'home', using: { value: :home_email } },
-                            { match: 'type', with: 'work', using: { value: :work_email } },
-                          ]
-                        }
-                      )
-
-                      expect(scim_hash).to eql({
-                        'emails' => [
-                          {
-                            'type' => 'home',
-                            'value' => 'home@test.com'
-                          },
-                          {
-                            'type' => 'work',
-                            'value' => nil
-                          }
-                        ]
-                      })
-                    end
-
-                    it 'handles simple values rather than object (Hash) values' do
-                      path      = [ 'test' ]
-                      value     = 42
-                      scim_hash = {
-                        'test' => [
-                          '21',
-                          '42',
-                          '15'
-                        ]
-                      }.with_indifferent_case_insensitive_access()
-
-                      @instance.send(
-                        :from_patch_backend!,
-                        nature:        'remove',
-                        path:          path,
-                        value:         value,
-                        altering_hash: scim_hash,
-                        with_attr_map: {
-                          test: []
-                        }
-                      )
-
-                      expect(scim_hash).to eql({
-                        'test' => [
-                          '21',
-                          '15'
-                        ]
-                      })
-                    end
-                  end
-                end # "context 'Microsoft-style payload' do"
-
-                # https://help.salesforce.com/s/articleView?id=sf.identity_scim_manage_groups.htm&type=5
-                #
-                context 'Salesforce-style payload' do
-                  it 'removes identified user' do
-                    path      = [ 'members' ]
-                    value     = { 'members' => [ { '$ref' => nil, 'value' => 'f648f8d5ea4e4cd38e9c' } ] }
-                    scim_hash = {
-                      'displayname' => 'Mock group',
-                      'members'     => [
-                        {
-                          'value'   => '50ca93d04ab0c2de4772',
-                          'display' => 'Ingrid Smith',
-                          'type'    => 'User'
-                        },
-                        {
-                          'value'   => 'f648f8d5ea4e4cd38e9c',
-                          'display' => 'Fred Smith',
-                          'type'    => 'User'
-                        }
-                      ]
-                    }.with_indifferent_case_insensitive_access()
-
-                    @instance.send(
-                      :from_patch_backend!,
-                      nature:        'remove',
-                      path:          path,
-                      value:         value,
-                      altering_hash: scim_hash,
-                      with_attr_map: {
-                        displayName: :name,
-                        members:     [
-                          list:  :members,
-                          using: {
-                            value:   :id,
-                            display: :full_name,
-                            type:    'User'
-                          }
-                        ]
-                      }
-                    )
-
-                    expect(scim_hash).to eql({
-                      'displayname' => 'Mock group',
-                      'members'     => [
-                        {
-                          'value'   => '50ca93d04ab0c2de4772',
-                          'display' => 'Ingrid Smith',
-                          'type'    => 'User'
-                        }
-                      ]
-                    })
-                  end
-
-                  it 'matches the "members" key case-insensitive' do
-                    path      = [ 'members' ]
-                    value     = { 'MEMBERS' => [ { '$ref' => nil, 'value' => 'f648f8d5ea4e4cd38e9c' } ] }
-                    scim_hash = {
-                      'displayname' => 'Mock group',
-                      'members'     => [
-                        {
-                          'value'   => 'f648f8d5ea4e4cd38e9c',
-                          'display' => 'Fred Smith',
-                          'type'    => 'User'
-                        },
-                        {
-                          'value'   => 'a774d480e8112101375b',
-                          'display' => 'Taylor Smith',
-                          'type'    => 'User'
-                        }
-                      ]
-                    }.with_indifferent_case_insensitive_access()
-
-                    @instance.send(
-                      :from_patch_backend!,
-                      nature:        'remove',
-                      path:          path,
-                      value:         value,
-                      altering_hash: scim_hash,
-                      with_attr_map: {
-                        displayName: :name,
-                        members:     [
-                          list:  :members,
-                          using: {
-                            value:   :id,
-                            display: :full_name,
-                            type:    'User'
-                          }
-                        ]
-                      }
-                    )
-
-                    expect(scim_hash).to eql({
-                      'displayname' => 'Mock group',
-                      'members'     => [
-                        {
-                          'value'   => 'a774d480e8112101375b',
-                          'display' => 'Taylor Smith',
-                          'type'    => 'User'
-                        }
-                      ]
-                    })
-                  end
-
-                  it 'ignores unrecognised users' do
-                    path      = [ 'members' ]
-                    value     = { 'members' => [ { '$ref' => nil, 'value' => '11b054a9c85216ed9356' } ] }
-                    scim_hash = {
-                      'displayname' => 'Mock group',
-                      'members'     => [
-                        {
-                          'value'   => 'f648f8d5ea4e4cd38e9c',
-                          'display' => 'Fred Smith',
-                          'type'    => 'User'
-                        }
-                      ]
-                    }.with_indifferent_case_insensitive_access()
-
-                    @instance.send(
-                      :from_patch_backend!,
-                      nature:        'remove',
-                      path:          path,
-                      value:         value,
-                      altering_hash: scim_hash,
-                      with_attr_map: {
-                        displayName: :name,
-                        members:     [
-                          list:  :members,
-                          using: {
-                            value:   :id,
-                            display: :full_name,
-                            type:    'User'
-                          }
-                        ]
-                      }
-                    )
-
-                    # The 'value' mismatched, so the user was not removed.
-                    #
-                    expect(scim_hash).to eql({
-                      'displayname' => 'Mock group',
-                      'members'     => [
-                        {
-                          'value'   => 'f648f8d5ea4e4cd38e9c',
-                          'display' => 'Fred Smith',
-                          'type'    => 'User'
-                        }
-                      ]
-                    })
-                  end
-                end # "context 'Salesforce-style payload' do"
-              end # "context 'special cases' do"
             end # context 'when prior value already exists' do
 
             context 'when value is not present' do
@@ -2379,8 +1214,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'remove',
                   path:          path,
                   value:         nil,
-                  altering_hash: scim_hash,
-                  with_attr_map: { userName: :user_name }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash).to be_empty
@@ -2395,8 +1229,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'remove',
                   path:          path,
                   value:         nil,
-                  altering_hash: scim_hash,
-                  with_attr_map: { name: { givenName: :first_name, familyName: :last_name } }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['name']).to_not have_key('givenName')
@@ -2420,13 +1253,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'remove',
                     path:          path,
                     value:         nil,
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'].size).to eql(1)
@@ -2448,13 +1275,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'remove',
                     path:          path,
                     value:         nil,
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'].size).to eql(1)
@@ -2477,13 +1298,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'remove',
                     path:          path,
                     value:         nil,
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'].size).to eql(1)
@@ -2501,13 +1316,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'remove',
                     path:          path,
                     value:         nil,
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash).to be_empty
@@ -2529,13 +1338,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'remove',
                     path:          path,
                     value:         nil,
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'].size).to eql(1)
@@ -2552,13 +1355,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'remove',
                   path:          path,
                   value:         nil,
-                  altering_hash: scim_hash,
-                  with_attr_map: {
-                    emails: [
-                      { match: 'type', with: 'home', using: { value: :home_email } },
-                      { match: 'type', with: 'work', using: { value: :work_email } },
-                    ]
-                  }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash).to_not have_key('emails')
@@ -2584,8 +1381,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'replace',
                   path:          path,
                   value:         'foo',
-                  altering_hash: scim_hash,
-                  with_attr_map: { userName: :user_name }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['userName']).to eql('foo')
@@ -2600,8 +1396,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'replace',
                   path:          path,
                   value:         'Baz',
-                  altering_hash: scim_hash,
-                  with_attr_map: { name: { givenName: :first_name, familyName: :last_name } }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['name']['givenName' ]).to eql('Baz')
@@ -2629,13 +1424,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'replace',
                     path:          path,
                     value:         'added_over_original@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
@@ -2661,13 +1450,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'replace',
                     path:          path,
                     value:         'added_over_original@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
@@ -2694,13 +1477,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'replace',
                     path:          path,
                     value:         'added_over_original@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('added_over_original@test.com')
@@ -2729,13 +1506,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'replace',
                     path:          path,
                     value:         {'type' => 'home', 'primary' => true, 'value' => 'home@test.com'},
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'].size).to eql(2)
@@ -2769,13 +1540,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'replace',
                     path:          path,
                     value:         {'type' => 'workinate', 'value' => 'replaced@test.com'},
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'].size).to eql(3)
@@ -2804,13 +1569,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'replace',
                   path:          path,
                   value:         [ { 'type' => 'work', 'value' => 'work@test.com' } ], # NOTE - to-add value is an Array (and must be)
-                  altering_hash: scim_hash,
-                  with_attr_map: {
-                    emails: [
-                      { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                      { match: 'type', with: 'work', using: { value: :work_email } },
-                    ]
-                  }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['emails'].size).to eql(1)
@@ -2829,8 +1588,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'replace',
                   path:          path,
                   value:         'foo',
-                  altering_hash: scim_hash,
-                  with_attr_map: { userName: :user_name }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['userName']).to eql('foo')
@@ -2845,8 +1603,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'replace',
                   path:          path,
                   value:         'Baz',
-                  altering_hash: scim_hash,
-                  with_attr_map: { name: { givenName: :first_name, familyName: :last_name } }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['name']['givenName']).to eql('Baz')
@@ -2872,13 +1629,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'replace',
                     path:          path,
                     value:         'added@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
@@ -2903,13 +1654,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'replace',
                     path:          path,
                     value:         'added@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('home@test.com')
@@ -2934,13 +1679,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'replace',
                     path:          path,
                     value:         'added@test.com',
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'][0]['value']).to eql('added@test.com')
@@ -2958,13 +1697,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'replace',
                     path:          path,
                     value:         {'type' => 'work', 'value' => 'work@test.com'},
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'].size).to eql(1)
@@ -2988,13 +1721,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                     nature:        'replace',
                     path:          path,
                     value:         {'type' => 'work', 'value' => 'work@test.com'},
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      emails: [
-                        { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                        { match: 'type', with: 'work', using: { value: :work_email } },
-                      ]
-                    }
+                    altering_hash: scim_hash
                   )
 
                   expect(scim_hash['emails'].size).to eql(2)
@@ -3013,41 +1740,13 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'replace',
                   path:          path,
                   value:         [ { 'type' => 'work', 'value' => 'work@test.com' } ], # NOTE - to-add value is an Array (and must be)
-                  altering_hash: scim_hash,
-                  with_attr_map: {
-                    emails: [
-                      { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                      { match: 'type', with: 'work', using: { value: :work_email } },
-                    ]
-                  }
+                  altering_hash: scim_hash
                 )
 
                 expect(scim_hash['emails'].size).to eql(1)
                 expect(scim_hash['emails'][0]['type' ]).to eql('work')
                 expect(scim_hash['emails'][0]['value']).to eql('work@test.com')
               end
-
-              context 'when prior value already exists, and no path' do
-                it 'simple value: overwrites' do
-                  path      = [ 'root' ]
-                  scim_hash = { 'root' => { 'userName' => 'bar', 'active' => true } }.with_indifferent_case_insensitive_access()
-
-                  @instance.send(
-                    :from_patch_backend!,
-                    nature:        'replace',
-                    path:          path,
-                    value:         { 'active' => false }.with_indifferent_case_insensitive_access(),
-                    altering_hash: scim_hash,
-                    with_attr_map: {
-                      userName: :user_name,
-                      active:   :active
-                    }
-                  )
-
-                  expect(scim_hash['root']['userName']).to eql('bar')
-                  expect(scim_hash['root']['active']).to eql(false)
-                end
-              end
             end # context 'when value is not present' do
           end # "context 'replace' do"
 
@@ -3162,8 +1861,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                 nature:        'add',
                 path:          ['complex[type eq "type1"]', 'data', 'nested[nature eq "nature2"]', 'info'],
                 value:         [{ 'deeper' => 'addition' }],
-                altering_hash: scim_hash,
-                with_attr_map: @contrived_class.scim_attributes_map()
+                altering_hash: scim_hash
               )
 
               expect(scim_hash.dig('complex', 0, 'data', 'nested', 0, 'info').count).to eql(1) # Unchanged
@@ -3186,8 +1884,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                 nature:        'replace',
                 path:          ['complex[type eq "type1"]', 'data', 'nested[nature eq "nature2"]', 'info'],
                 value:         [{ 'deeper' => 'addition' }],
-                altering_hash: scim_hash,
-                with_attr_map: @contrived_class.scim_attributes_map()
+                altering_hash: scim_hash
               )
 
               expect(scim_hash.dig('complex', 0, 'data', 'nested', 0, 'info').count).to eql(1) # Unchanged?
@@ -3204,25 +1901,24 @@ RSpec.describe Scimitar::Resources::Mixin do
               expect(scim_hash.dig('complex', 2, 'data', 'nested', 0, 'info', 0, 'deep')).to eql('nature2deep3') # Unchanged
             end
 
-            it 'removes via clearing to "nil" or empty Array across multiple deep matching points' do
+            it 'removes across multiple deep matching points' do
               scim_hash          = @original_hash.deep_dup().with_indifferent_case_insensitive_access()
               contrived_instance = @contrived_class.new
               contrived_instance.send(
                 :from_patch_backend!,
                 nature:        'remove',
                 path:          ['complex[type eq "type1"]', 'data', 'nested[nature eq "nature2"]', 'info'],
-                value:         nil,
-                altering_hash: scim_hash,
-                with_attr_map: @contrived_class.scim_attributes_map()
+                value:         [{ 'deeper' => 'addition' }],
+                altering_hash: scim_hash
               )
 
               expect(scim_hash.dig('complex', 0, 'data', 'nested', 0, 'info').count).to eql(1) # Unchanged
-              expect(scim_hash.dig('complex', 0, 'data', 'nested', 1, 'info')).to eql([])
+              expect(scim_hash.dig('complex', 0, 'data', 'nested', 1, 'info')).to be_nil
               expect(scim_hash.dig('complex', 0, 'data', 'nested', 2, 'nature')).to be_present
-              expect(scim_hash.dig('complex', 0, 'data', 'nested', 1, 'info')).to eql([])
+              expect(scim_hash.dig('complex', 0, 'data', 'nested', 1, 'info')).to be_nil
               expect(scim_hash.dig('complex', 0, 'data', 'nested', 2, 'nature')).to be_present
 
-              expect(scim_hash.dig('complex', 1, 'data', 'nested', 0, 'info')).to eql([])
+              expect(scim_hash.dig('complex', 1, 'data', 'nested', 0, 'info')).to be_nil
               expect(scim_hash.dig('complex', 1, 'data', 'nested', 0, 'nature')).to be_present
 
               expect(scim_hash.dig('complex', 2, 'data', 'nested', 0, 'info').count).to eql(1) # Unchanged
@@ -3256,13 +1952,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'replace',
                   path:          path,
                   value:         'ignored',
-                  altering_hash: scim_hash,
-                  with_attr_map: {
-                    emails: [
-                      { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                      { match: 'type', with: 'work', using: { value: :work_email } },
-                    ]
-                  }
+                  altering_hash: scim_hash
                 )
               end.to raise_error(Scimitar::ErrorResponse) { |e| expect(e.as_json['scimType']).to eql('invalidSyntax') }
             end
@@ -3279,8 +1969,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'replace',
                   path:          path,
                   value:         'ignored',
-                  altering_hash: scim_hash,
-                  with_attr_map: { userName: :user_name }
+                  altering_hash: scim_hash
                 )
               end.to raise_error(Scimitar::ErrorResponse) { |e| expect(e.as_json['scimType']).to eql('invalidSyntax') }
             end
@@ -3300,13 +1989,7 @@ RSpec.describe Scimitar::Resources::Mixin do
                   nature:        'replace',
                   path:          path,
                   value:         'ignored',
-                  altering_hash: scim_hash,
-                  with_attr_map: {
-                    emails: [
-                      { match: 'type', with: 'home', using: { value: :home_email, primary: true } },
-                      { match: 'type', with: 'work', using: { value: :work_email } },
-                    ]
-                  }
+                  altering_hash: scim_hash
                 )
               end.to raise_error(Scimitar::ErrorResponse) { |e| expect(e.as_json['scimType']).to eql('invalidSyntax') }
             end
@@ -3320,14 +2003,6 @@ RSpec.describe Scimitar::Resources::Mixin do
       #
       context 'public interface' do
         shared_examples 'a patcher' do | force_upper_case: |
-          it 'gives the user a comprehensible error when operations are missing' do
-            patch = { 'schemas' => ['urn:ietf:params:scim:api:messages:2.0:PatchOp'] }
-
-            expect do
-              @instance.from_scim_patch!(patch_hash: patch)
-            end.to raise_error Scimitar::InvalidSyntaxError, "Missing PATCH \"operations\""
-          end
-
           it 'which updates simple values' do
             @instance.update!(username: 'foo')
 
@@ -3349,28 +2024,6 @@ RSpec.describe Scimitar::Resources::Mixin do
             expect(@instance.username).to eql('1234')
           end
 
-          it 'which updates nested values using root syntax' do
-            @instance.update!(first_name: 'Foo', last_name: 'Bar')
-
-            path = 'name.givenName'
-            path = path.upcase if force_upper_case
-
-            patch = {
-              'schemas'    => ['urn:ietf:params:scim:api:messages:2.0:PatchOp'],
-              'Operations' => [
-                {
-                  'op'    => 'replace',
-                  'value' => {
-                    path => 'Baz'
-                  }
-                }
-              ]
-            }
-
-            @instance.from_scim_patch!(patch_hash: patch)
-            expect(@instance.first_name).to eql('Baz')
-          end
-
           it 'which updates nested values' do
             @instance.update!(first_name: 'Foo', last_name: 'Bar')
 
@@ -3392,38 +2045,6 @@ RSpec.describe Scimitar::Resources::Mixin do
             expect(@instance.first_name).to eql('Baz')
           end
 
-          # Note odd ":" separating schema ID from first attribute, although
-          # the nature of JSON rendering / other payloads might lead you to
-          # expect a "." as with any other path component.
-          #
-          # Note the ":" separating the schema ID (URN) from the attribute.
-          # The nature of JSON rendering / other payloads might lead you to
-          # expect a "." as with any complex types, but that's not the case;
-          # see https://tools.ietf.org/html/rfc7644#section-3.10, or
-          # https://tools.ietf.org/html/rfc7644#section-3.5.2 of which in
-          # particular, https://tools.ietf.org/html/rfc7644#page-35.
-          #
-          it 'which updates attributes defined by extension schema' do
-            @instance.update!(department: 'SOMEDPT')
-
-            path = 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:department'
-            path = path.upcase if force_upper_case
-
-            patch = {
-              'schemas'    => ['urn:ietf:params:scim:api:messages:2.0:PatchOp'],
-              'Operations' => [
-                {
-                  'op'    => 'replace',
-                  'path'  => path,
-                  'value' => 'OTHERDPT'
-                }
-              ]
-            }
-
-            @instance.from_scim_patch!(patch_hash: patch)
-            expect(@instance.department).to eql('OTHERDPT')
-          end
-
           it 'which updates with filter match' do
             @instance.update!(work_email_address: 'work@test.com', home_email_address: 'home@test.com')