scimitar 1.4.0 → 1.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd0efbdecece6297062b46cf46bdeaccd8330cd58fc94fb2bcb0de7c7bb90806
-  data.tar.gz: 7f3528ee080f0f295d03c77fba1586484b5cadd6ef5e4de1fc00d7807ec7a0c1
+  metadata.gz: b55b1f0a0a700b57690cb05fc02241cf47f60a4ad8c92946a32366c90ee56d8c
+  data.tar.gz: a7143dcd7d1381250e66529c70288659a2018fb26fc16639c14ba796acc805d5
 SHA512:
-  metadata.gz: 8044cc09d7b964401b09e6fe8ccfa272b6c67ab97687c79a151010a447109f9e671bb864094905b2495100591e2472f673ce2b977fc07f2a13213a8d4fbc75b1
-  data.tar.gz: 51a5522fcf948d3b9f19c6bc5b28732f0fb4537034106d47dca83d7d043d5749d9adf1c31acf10fc7eb79a63739787a0ec42f0a261eb293072634aabca0ec92d
+  metadata.gz: fb740b528770a918fc3237cabdc953affcde23fa7787cc9e9383a6d71b104e2d6325c2829545d367983a3bb64435179a0523b6d785d8e6d3eb7b2bfdb6c82748
+  data.tar.gz: 9f73bcafefbd7de57f258d1dc1c18e020b8dd7bca6330f7b288e308168daf7cb698051a9f2d4eaee9717139978df4e7a9fe854ba269ab94b2b46f1030d2ab9db

data/app/controllers/scimitar/application_controller.rb

@@ -99,10 +99,10 @@ module Scimitar
       def require_scim
         scim_mime_type = Mime::Type.lookup_by_extension(:scim).to_s
 
-        if request.content_type.nil?
+        if request.media_type.nil? || request.media_type.empty?
           request.format = :scim
           request.headers['CONTENT_TYPE'] = scim_mime_type
-        elsif request.content_type&.downcase == scim_mime_type
+        elsif request.media_type.downcase == scim_mime_type
           request.format = :scim
         elsif request.format == :scim
           request.headers['CONTENT_TYPE'] = scim_mime_type

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

@@ -443,9 +443,30 @@ module Scimitar
               ci_scim_hash = { 'root' => ci_scim_hash }.with_indifferent_case_insensitive_access()
             end
 
+            # Handle extension schema. Contributed by @bettysteger and
+            # @MorrisFreeman via:
+            #
+            #   https://github.com/RIPAGlobal/scimitar/issues/48
+            #   https://github.com/RIPAGlobal/scimitar/pull/49
+            #
+            # 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.
+            #
+            paths = []
+            self.class.scim_resource_type.extended_schemas.each do |schema|
+              path_str.downcase.split(schema.id.downcase + ':').drop(1).each do |path|
+                paths += [schema.id] + path.split('.')
+              end
+            end
+            paths = path_str.split('.') if paths.empty?
+
             self.from_patch_backend!(
               nature:        nature,
-              path:          (path_str || '').split('.'),
+              path:          paths,
               value:         value,
               altering_hash: ci_scim_hash
             )
@@ -616,7 +637,19 @@ module Scimitar
                 attrs_map_or_leaf_value.each do | scim_attribute, sub_attrs_map_or_leaf_value |
                   next if scim_attribute&.to_s&.downcase == 'id' && path.empty?
 
-                  sub_scim_hash_or_leaf_value = scim_hash_or_leaf_value&.dig(scim_attribute.to_s)
+                  # Handle extension schema. Contributed by @bettysteger and
+                  # @MorrisFreeman via:
+                  #
+                  #   https://github.com/RIPAGlobal/scimitar/issues/48
+                  #   https://github.com/RIPAGlobal/scimitar/pull/49
+                  #
+                  attribute_tree = []
+                  resource_class.extended_schemas.each do |schema|
+                    attribute_tree << schema.id and break if schema.scim_attributes.any? { |attribute| attribute.name == scim_attribute.to_s }
+                  end
+                  attribute_tree << scim_attribute.to_s
+
+                  sub_scim_hash_or_leaf_value = scim_hash_or_leaf_value&.dig(*attribute_tree)
 
                   self.from_scim_backend!(
                     attrs_map_or_leaf_value: sub_attrs_map_or_leaf_value,
@@ -901,14 +934,86 @@ module Scimitar
                   else
                     altering_hash[path_component] = value
                   end
+
                 when 'replace'
                   if path_component == 'root'
                     altering_hash[path_component].merge!(value)
                   else
                     altering_hash[path_component] = value
                   end
+
+                # The array check handles payloads seen from e.g. Microsoft for
+                # remove-user-from-group, where contrary to examples in the RFC
+                # which would imply "payload removes all users", there is the
+                # clear intent to remove just one.
+                #
+                # https://tools.ietf.org/html/rfc7644#section-3.5.2.2
+                # https://learn.microsoft.com/en-us/azure/active-directory/app-provisioning/use-scim-to-provision-users-and-groups#update-group-remove-members
+                #
+                # Since remove-all in the face of remove-one is destructive, we
+                # do a special check here to see if there's an array value for
+                # the array path that the payload yielded. If so, we can match
+                # each value against array items and remove just those items.
+                #
+                # There is an additional special case to handle a bad example
+                # from Salesforce:
+                #
+                #   https://help.salesforce.com/s/articleView?id=sf.identity_scim_manage_groups.htm&type=5
+                #
                 when 'remove'
-                  altering_hash.delete(path_component)
+                  if altering_hash[path_component].is_a?(Array) && value.present?
+
+                    # Handle bad Salesforce example. That might be simply a
+                    # documentation error, but just in case...
+                    #
+                    value = value.values.first if (
+                      path_component&.downcase == 'members' &&
+                      value.is_a?(Hash)                     &&
+                      value.keys.size == 1                  &&
+                      value.keys.first&.downcase == 'members'
+                    )
+
+                    # The Microsoft example provides an array of values, but we
+                    # may as well cope with a value specified 'flat'. Promote
+                    # such a thing to an Array to simplify the following code.
+                    #
+                    value = [value] unless value.is_a?(Array)
+
+                    # For each value item, delete matching array entries. The
+                    # concept of "matching" is:
+                    #
+                    # * For simple non-Hash values (if possible) just delete on
+                    #   an exact match
+                    #
+                    # * For Hash-based values, only delete if all 'patch' keys
+                    #   are present in the resource and all values thus match.
+                    #
+                    # Special case to ignore '$ref' from the Microsoft payload.
+                    #
+                    # Note coercion to strings to account for SCIM vs the usual
+                    # tricky case of underlying implementations with (say)
+                    # integer primary keys, which all end up as strings anyway.
+                    #
+                    value.each do | value_item |
+                      altering_hash[path_component].delete_if do | item |
+                        if item.is_a?(Hash) && value_item.is_a?(Hash)
+                          matched_all = true
+                          value_item.each do | value_key, value_value |
+                            next if value_key == '$ref'
+                            if ! item.key?(value_key) || item[value_key]&.to_s != value_value&.to_s
+                              matched_all = false
+                            end
+                          end
+                          matched_all
+                        else
+                          item&.to_s == value_item&.to_s
+                        end
+                      end
+                    end
+                  else
+                    altering_hash.delete(path_component)
+                  end
+
               end
             end
           end

data/lib/scimitar/version.rb

@@ -3,11 +3,11 @@ module Scimitar
   # Gem version. If this changes, be sure to re-run "bundle install" or
   # "bundle update".
   #
-  VERSION = '1.4.0'
+  VERSION = '1.5.2'
 
   # Date for VERSION. If this changes, be sure to re-run "bundle install"
   # or "bundle update".
   #
-  DATE = '2023-01-26'
+  DATE = '2023-03-21'
 
 end

data/spec/apps/dummy/app/models/mock_user.rb

@@ -13,6 +13,8 @@ class MockUser < ActiveRecord::Base
     work_email_address
     home_email_address
     work_phone_number
+    organization
+    department
   }
 
   has_and_belongs_to_many :mock_groups
@@ -82,7 +84,13 @@ class MockUser < ActiveRecord::Base
           }
         }
       ],
-      active: :is_active
+      active: :is_active,
+
+      # Custom extension schema - see configuration in
+      # "spec/apps/dummy/config/initializers/scimitar.rb".
+      #
+      organization: :organization,
+      department:   :department
     }
   end
 

data/spec/apps/dummy/config/initializers/scimitar.rb

@@ -1,5 +1,14 @@
 # Test app configuration.
 #
+# Note that as a result of https://github.com/RIPAGlobal/scimitar/issues/48,
+# tests include a custom extension of the core User schema. A shortcoming of
+# some of the code from which Scimitar was originally built is that those
+# extensions are done with class-level ivars, so it is largely impossible (or
+# at least, impractical in tests) to avoid polluting the core class itself
+# with the extension.
+#
+# All related schema tests are written with this in mind.
+#
 Scimitar.engine_configuration = Scimitar::EngineConfiguration.new({
 
   application_controller_mixin: Module.new do
@@ -12,3 +21,31 @@ Scimitar.engine_configuration = Scimitar::EngineConfiguration.new({
   end
 
 })
+
+module ScimSchemaExtensions
+  module User
+    class Enterprise < Scimitar::Schema::Base
+      def initialize(options = {})
+        super(
+          name:            'ExtendedUser',
+          description:     'Enterprise extension for a User',
+          id:              self.class.id,
+          scim_attributes: self.class.scim_attributes
+        )
+      end
+
+      def self.id
+        'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User'
+      end
+
+      def self.scim_attributes
+        [
+          Scimitar::Schema::Attribute.new(name: 'organization', type: 'string'),
+          Scimitar::Schema::Attribute.new(name: 'department',   type: 'string')
+        ]
+      end
+    end
+  end
+end
+
+Scimitar::Resources::User.extend_schema ScimSchemaExtensions::User::Enterprise

data/spec/apps/dummy/config/routes.rb

@@ -15,6 +15,7 @@ Rails.application.routes.draw do
 
   get    'Groups',     to: 'mock_groups#index'
   get    'Groups/:id', to: 'mock_groups#show'
+  patch  'Groups/:id', to: 'mock_groups#update'
 
   # For testing blocks passed to ActiveRecordBackedResourcesController#destroy
   #

data/spec/apps/dummy/db/migrate/20210304014602_create_mock_users.rb

@@ -3,6 +3,8 @@ class CreateMockUsers < ActiveRecord::Migration[6.1]
     create_table :mock_users, id: :uuid, primary_key: :primary_key do |t|
       t.timestamps
 
+      # Support part of the core schema
+      #
       t.text :scim_uid
       t.text :username
       t.text :first_name
@@ -10,6 +12,12 @@ class CreateMockUsers < ActiveRecord::Migration[6.1]
       t.text :work_email_address
       t.text :home_email_address
       t.text :work_phone_number
+
+      # Support the custom extension schema - see configuration in
+      # "spec/apps/dummy/config/initializers/scimitar.rb".
+      #
+      t.text :organization
+      t.text :department
     end
   end
 end

data/spec/apps/dummy/db/schema.rb

@@ -39,6 +39,8 @@ ActiveRecord::Schema.define(version: 2021_03_08_044214) do
     t.text "work_email_address"
     t.text "home_email_address"
     t.text "work_phone_number"
+    t.text "organization"
+    t.text "department"
   end
 
   add_foreign_key "mock_groups_users", "mock_groups"

data/spec/controllers/scimitar/schemas_controller_spec.rb

@@ -14,9 +14,9 @@ RSpec.describe Scimitar::SchemasController do
       get :index, params: { format: :scim }
       expect(response).to be_ok
       parsed_body = JSON.parse(response.body)
-      expect(parsed_body.length).to eql(2)
+      expect(parsed_body.length).to eql(3)
       schema_names = parsed_body.map {|schema| schema['name']}
-      expect(schema_names).to match_array(['User', 'Group'])
+      expect(schema_names).to match_array(['User', 'ExtendedUser', 'Group'])
     end
 
     it 'returns only the User schema when its id is provided' do

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

@@ -250,90 +250,185 @@ RSpec.describe Scimitar::Resources::Base do
   end # "context 'dynamic setters based on schema' do"
 
   context 'schema extension' do
-    ThirdCustomSchema = Class.new(Scimitar::Schema::Base) do
-      def self.id
-        'custom-id'
-      end
+    context 'of custom schema' do
+      ThirdCustomSchema = Class.new(Scimitar::Schema::Base) do
+        def self.id
+          'custom-id'
+        end
 
-      def self.scim_attributes
-        [ Scimitar::Schema::Attribute.new(name: 'name', type: 'string') ]
+        def self.scim_attributes
+          [ Scimitar::Schema::Attribute.new(name: 'name', type: 'string') ]
+        end
       end
-    end
 
-    ExtensionSchema = Class.new(Scimitar::Schema::Base) do
-      def self.id
-        'extension-id'
-      end
+      ExtensionSchema = Class.new(Scimitar::Schema::Base) do
+        def self.id
+          'extension-id'
+        end
 
-      def self.scim_attributes
-        [ Scimitar::Schema::Attribute.new(name: 'relationship', type: 'string', required: true) ]
+        def self.scim_attributes
+          [ Scimitar::Schema::Attribute.new(name: 'relationship', type: 'string', required: true) ]
+        end
       end
-    end
 
-    let(:resource_class) {
-      Class.new(Scimitar::Resources::Base) do
-        set_schema ThirdCustomSchema
-        extend_schema ExtensionSchema
+      let(:resource_class) {
+        Class.new(Scimitar::Resources::Base) do
+          set_schema ThirdCustomSchema
+          extend_schema ExtensionSchema
 
-        def self.endpoint
-          '/gaga'
+          def self.endpoint
+            '/gaga'
+          end
+
+          def self.resource_type_id
+            'CustomResource'
+          end
         end
+      }
 
-        def self.resource_type_id
-          'CustomResource'
+      context '#initialize' do
+        it 'allows setting extension attributes' do
+          resource = resource_class.new('extension-id' => {relationship: 'GAGA'})
+          expect(resource.relationship).to eql('GAGA')
         end
-      end
-    }
+      end # "context '#initialize' do"
+
+      context '#as_json' do
+        it 'namespaces the extension attributes' do
+          resource = resource_class.new(relationship: 'GAGA')
+          hash = resource.as_json
+          expect(hash["schemas"]).to eql(['custom-id', 'extension-id'])
+          expect(hash["extension-id"]).to eql("relationship" => 'GAGA')
+        end
+      end # "context '#as_json' do"
 
-    context '#initialize' do
-      it 'allows setting extension attributes' do
-        resource = resource_class.new('extension-id' => {relationship: 'GAGA'})
-        expect(resource.relationship).to eql('GAGA')
-      end
-    end # "context '#initialize' do"
+      context '.resource_type' do
+        it 'appends the extension schemas' do
+          resource_type = resource_class.resource_type('http://gaga')
+          expect(resource_type.meta.location).to eql('http://gaga')
+          expect(resource_type.schemaExtensions.count).to eql(1)
+        end
 
-    context '#as_json' do
-      it 'namespaces the extension attributes' do
-        resource = resource_class.new(relationship: 'GAGA')
-        hash = resource.as_json
-        expect(hash["schemas"]).to eql(['custom-id', 'extension-id'])
-        expect(hash["extension-id"]).to eql("relationship" => 'GAGA')
-      end
-    end # "context '#as_json' do"
+        context 'validation' do
+          it 'validates into custom schema' do
+            resource = resource_class.new('extension-id' => {})
+            expect(resource.valid?).to eql(false)
 
-    context '.resource_type' do
-      it 'appends the extension schemas' do
-        resource_type = resource_class.resource_type('http://gaga')
-        expect(resource_type.meta.location).to eql('http://gaga')
-        expect(resource_type.schemaExtensions.count).to eql(1)
-      end
+            resource = resource_class.new('extension-id' => {relationship: 'GAGA'})
+            expect(resource.relationship).to eql('GAGA')
+            expect(resource.valid?).to eql(true)
+          end
+        end # context 'validation'
+      end # "context '.resource_type' do"
 
-      context 'validation' do
-        it 'validates into custom schema' do
-          resource = resource_class.new('extension-id' => {})
-          expect(resource.valid?).to eql(false)
+      context '.find_attribute' do
+        it 'finds in first schema' do
+          found = resource_class().find_attribute('name') # Defined in ThirdCustomSchema
+          expect(found).to be_present
+          expect(found.name).to eql('name')
+          expect(found.type).to eql('string')
+        end
 
-          resource = resource_class.new('extension-id' => {relationship: 'GAGA'})
-          expect(resource.relationship).to eql('GAGA')
-          expect(resource.valid?).to eql(true)
+        it 'finds across schemas' do
+          found = resource_class().find_attribute('relationship') # Defined in ExtensionSchema
+          expect(found).to be_present
+          expect(found.name).to eql('relationship')
+          expect(found.type).to eql('string')
         end
-      end # context 'validation'
-    end # "context '.resource_type' do"
+      end # "context '.find_attribute' do"
+    end # "context 'of custom schema' do"
 
-    context '.find_attribute' do
-      it 'finds in first schema' do
-        found = resource_class().find_attribute('name') # Defined in ThirdCustomSchema
-        expect(found).to be_present
-        expect(found.name).to eql('name')
-        expect(found.type).to eql('string')
-      end
+    context 'of core schema' do
+      EnterpriseExtensionSchema = Class.new(Scimitar::Schema::Base) do
+        def self.id
+          'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User'
+        end
 
-      it 'finds across schemas' do
-        found = resource_class().find_attribute('relationship') # Defined in ExtensionSchema
-        expect(found).to be_present
-        expect(found.name).to eql('relationship')
-        expect(found.type).to eql('string')
+        def self.scim_attributes
+          [
+            Scimitar::Schema::Attribute.new(name: 'organization', type: 'string'),
+            Scimitar::Schema::Attribute.new(name: 'department',   type: 'string')
+          ]
+        end
       end
-    end # "context '.find_attribute' do"
+
+      let(:resource_class) {
+        Class.new(Scimitar::Resources::Base) do
+          set_schema Scimitar::Schema::User
+          extend_schema EnterpriseExtensionSchema
+
+          def self.endpoint
+            '/Users'
+          end
+
+          def self.resource_type_id
+            'User'
+          end
+        end
+      }
+
+      context '#initialize' do
+        it 'allows setting extension attributes' do
+          resource = resource_class.new('urn:ietf:params:scim:schemas:extension:enterprise:2.0:User' => {organization: 'SOMEORG', department: 'SOMEDPT'})
+
+          expect(resource.organization).to eql('SOMEORG')
+          expect(resource.department  ).to eql('SOMEDPT')
+        end
+      end # "context '#initialize' do"
+
+      context '#as_json' do
+        it 'namespaces the extension attributes' do
+          resource = resource_class.new(organization: 'SOMEORG', department: 'SOMEDPT')
+          hash = resource.as_json
+
+          expect(hash['schemas']).to eql(['urn:ietf:params:scim:schemas:core:2.0:User', 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User'])
+          expect(hash['urn:ietf:params:scim:schemas:extension:enterprise:2.0:User']).to eql('organization' => 'SOMEORG', 'department' => 'SOMEDPT')
+        end
+      end # "context '#as_json' do"
+
+      context '.resource_type' do
+        it 'appends the extension schemas' do
+          resource_type = resource_class.resource_type('http://example.com')
+          expect(resource_type.meta.location).to eql('http://example.com')
+          expect(resource_type.schemaExtensions.count).to eql(1)
+        end
+
+        context 'validation' do
+          it 'validates into custom schema' do
+            resource = resource_class.new('urn:ietf:params:scim:schemas:extension:enterprise:2.0:User' => {})
+            expect(resource.valid?).to eql(false)
+
+            resource = resource_class.new(
+              'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User' => {
+                userName:     'SOMEUSR',
+                organization: 'SOMEORG',
+                department:   'SOMEDPT'
+              }
+            )
+
+            expect(resource.organization).to eql('SOMEORG')
+            expect(resource.department  ).to eql('SOMEDPT')
+            expect(resource.valid?      ).to eql(true)
+          end
+        end # context 'validation'
+      end # "context '.resource_type' do"
+
+      context '.find_attribute' do
+        it 'finds in first schema' do
+          found = resource_class().find_attribute('userName') # Defined in Scimitar::Schema::User
+
+          expect(found).to be_present
+          expect(found.name).to eql('userName')
+          expect(found.type).to eql('string')
+        end
+
+        it 'finds across schemas' do
+          found = resource_class().find_attribute('organization') # Defined in EnterpriseExtensionSchema
+          expect(found).to be_present
+          expect(found.name).to eql('organization')
+          expect(found.type).to eql('string')
+        end
+      end # "context '.find_attribute' do"
+    end # "context 'of core schema' do"
   end # "context 'schema extension' do"
 end