scimitar 1.6.0 → 1.7.1

data/app/controllers/scimitar/active_record_backed_resources_controller.rb

@@ -153,7 +153,13 @@ module Scimitar
       # Save a record, dealing with validation exceptions by raising SCIM
       # errors.
       #
-      # +record+:: ActiveRecord subclass to save (via #save!).
+      # +record+:: ActiveRecord subclass to save.
+      #
+      # If you just let this superclass handle things, it'll call the standard
+      # +#save!+ method on the record. If you pass a block, then this block is
+      # invoked and passed the ActiveRecord model instance to be saved. You can
+      # then do things like calling a different method, using a service object
+      # of some kind, perform audit-related operations and so-on.
       #
       # The return value is not used internally, making life easier for
       # overriding subclasses to "do the right thing" / avoid mistakes (instead
@@ -161,10 +167,22 @@ module Scimitar
       # and relying upon this to generate correct response payloads - an early
       # version of the gem did this and it caused a confusing subclass bug).
       #
-      def save!(record)
-        record.save!
-
+      def save!(record, &block)
+        if block_given?
+          yield(record)
+        else
+          record.save!
+        end
       rescue ActiveRecord::RecordInvalid => exception
+        handle_invalid_record(exception.record)
+      end
+
+      # Deal with validation errors by responding with an appropriate SCIM
+      # error.
+      #
+      # +record+:: The record with validation errors.
+      #
+      def handle_invalid_record(record)
         joined_errors = record.errors.full_messages.join('; ')
 
         # https://tools.ietf.org/html/rfc7644#page-12

data/app/controllers/scimitar/application_controller.rb

@@ -124,8 +124,13 @@ module Scimitar
         #
         # https://stackoverflow.com/questions/10239970/what-is-the-delimiter-for-www-authenticate-for-multiple-schemes
         #
-        response.set_header('WWW_AUTHENTICATE', 'Basic' ) if Scimitar.engine_configuration.basic_authenticator.present?
-        response.set_header('WWW_AUTHENTICATE', 'Bearer') if Scimitar.engine_configuration.token_authenticator.present?
+        response.set_header('WWW-Authenticate', 'Basic' ) if Scimitar.engine_configuration.basic_authenticator.present?
+        response.set_header('WWW-Authenticate', 'Bearer') if Scimitar.engine_configuration.token_authenticator.present?
+
+        # No matter what a caller might request via headers, the only content
+        # type we can ever respond with is JSON-for-SCIM.
+        #
+        response.set_header('Content-Type', "#{Mime::Type.lookup_by_extension(:scim)}; charset=utf-8")
       end
 
       def authenticate

data/app/controllers/scimitar/schemas_controller.rb

@@ -4,6 +4,11 @@ module Scimitar
   class SchemasController < ApplicationController
     def index
       schemas = Scimitar::Engine.schemas
+
+      schemas.each do |schema|
+        schema.meta.location = scim_schemas_url(name: schema.id)
+      end
+
       schemas_by_id = schemas.reduce({}) do |hash, schema|
         hash[schema.id] = schema
         hash

data/app/models/scimitar/errors.rb

@@ -1,6 +1,6 @@
 module Scimitar
   module Errors
-    def add_errors_from_hash(errors_hash, prefix: nil)
+    def add_errors_from_hash(errors_hash:, prefix: nil)
       errors_hash.each_pair do |key, value|
         new_key = prefix.nil? ? key : "#{prefix}.#{key}".to_sym
         if value.is_a?(Array)

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

@@ -139,13 +139,23 @@ module Scimitar
 
       def as_json(options = {})
         self.meta = Meta.new unless self.meta && self.meta.is_a?(Meta)
-        meta.resourceType = self.class.resource_type_id
-        original_hash = super(options).except('errors')
+        self.meta.resourceType = self.class.resource_type_id
+
+        non_returnable_attributes = self.class
+          .schemas
+          .flat_map(&:scim_attributes)
+          .filter_map { |attribute| attribute.name if attribute.returned == 'never' }
+
+        non_returnable_attributes << 'errors'
+
+        original_hash = super(options).except(*non_returnable_attributes)
         original_hash.merge!('schemas' => self.class.schemas.map(&:id))
+
         self.class.extended_schemas.each do |extension_schema|
           extension_attributes = extension_schema.scim_attributes.map(&:name)
           original_hash.merge!(extension_schema.id => original_hash.extract!(*extension_attributes))
         end
+
         original_hash
       end
 

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

@@ -88,19 +88,28 @@ module Scimitar
         end
         value.class.schema.valid?(value)
         return true if value.errors.empty?
-        add_errors_from_hash(value.errors.to_hash, prefix: self.name)
+        add_errors_from_hash(errors_hash: value.errors.to_hash, prefix: self.name)
         false
       end
 
       def valid_simple_type?(value)
-        valid = (type == 'string' && value.is_a?(String)) ||
-          (type == 'boolean' && (value.is_a?(TrueClass) || value.is_a?(FalseClass))) ||
-          (type == 'integer' && (value.is_a?(Integer))) ||
-          (type == 'dateTime' && valid_date_time?(value))
-        errors.add(self.name, "has the wrong type. It has to be a(n) #{self.type}.") unless valid
+        if multiValued
+          valid = value.is_a?(Array) && value.all? { |v| simple_type?(v) }
+          errors.add(self.name, "or one of its elements has the wrong type. It has to be an array of #{self.type}s.") unless valid
+        else
+          valid = simple_type?(value)
+          errors.add(self.name, "has the wrong type. It has to be a(n) #{self.type}.") unless valid
+        end
         valid
       end
 
+      def simple_type?(value)
+        (type == 'string' && value.is_a?(String)) ||
+        (type == 'boolean' && (value.is_a?(TrueClass) || value.is_a?(FalseClass))) ||
+        (type == 'integer' && (value.is_a?(Integer))) ||
+        (type == 'dateTime' && valid_date_time?(value))
+      end
+
       def valid_date_time?(value)
         !!Time.iso8601(value)
       rescue ArgumentError

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

@@ -13,7 +13,7 @@ module Scimitar
 
       # Converts the schema to its json representation that will be returned by /SCHEMAS end-point of a SCIM service provider.
       def as_json(options = {})
-        @meta.location = Scimitar::Engine.routes.url_helpers.scim_schemas_path(name: id)
+        @meta.location ||= Scimitar::Engine.routes.url_helpers.scim_schemas_path(name: id)
         original = super
         original.merge('attributes' => original.delete('scim_attributes'))
       end
@@ -26,7 +26,9 @@ module Scimitar
       #
       def self.valid?(resource)
         cloned_scim_attributes.each do |scim_attribute|
-          resource.add_errors_from_hash(scim_attribute.errors.to_hash) unless scim_attribute.valid?(resource.send(scim_attribute.name))
+          unless scim_attribute.valid?(resource.send(scim_attribute.name))
+            resource.add_errors_from_hash(errors_hash: scim_attribute.errors.to_hash)
+          end
         end
       end
 

data/config/initializers/scimitar.rb

@@ -38,9 +38,10 @@ Rails.application.config.to_prepare do # (required for >= Rails 7 / Zeitwerk)
   Scimitar.engine_configuration = Scimitar::EngineConfiguration.new({
 
     # If you have filters you want to run for any Scimitar action/route, you
-    # can define them here. For example, you might use a before-action to set
-    # up some multi-tenancy related state, or skip Rails CSRF token
-    # verification. For example:
+    # can define them here. You can also override any shared controller methods
+    # here. For example, you might use a before-action to set up some
+    # multi-tenancy related state, skip Rails CSRF token verification, or
+    # customise how Scimitar generates URLs:
     #
     #     application_controller_mixin: Module.new do
     #       def self.included(base)
@@ -54,6 +55,10 @@ Rails.application.config.to_prepare do # (required for >= Rails 7 / Zeitwerk)
     #           prepend_before_action :setup_some_kind_of_multi_tenancy_data
     #         end
     #       end
+    #
+    #       def scim_schemas_url(options)
+    #         super(custom_param: 'value', **options)
+    #       end
     #     end, # ...other configuration entries might follow...
 
     # If you want to support username/password authentication:

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.6.0'
+  VERSION = '1.7.1'
 
   # Date for VERSION. If this changes, be sure to re-run "bundle install"
   # or "bundle update".
   #
-  DATE = '2023-09-25'
+  DATE = '2023-11-15'
 
 end

data/spec/apps/dummy/app/controllers/custom_save_mock_users_controller.rb

@@ -0,0 +1,24 @@
+# For tests only - uses custom 'save!' implementation which passes a block to
+# Scimitar::ActiveRecordBackedResourcesController#save!.
+#
+class CustomSaveMockUsersController < Scimitar::ActiveRecordBackedResourcesController
+
+  CUSTOM_SAVE_BLOCK_USERNAME_INDICATOR = 'Custom save-block invoked'
+
+  protected
+
+    def save!(_record)
+      super do | record |
+        record.update!(username: CUSTOM_SAVE_BLOCK_USERNAME_INDICATOR)
+      end
+    end
+
+    def storage_class
+      MockUser
+    end
+
+    def storage_scope
+      MockUser.all
+    end
+
+end

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

@@ -1,5 +1,7 @@
 class MockUser < ActiveRecord::Base
 
+  self.primary_key = :primary_key
+
   # ===========================================================================
   # TEST ATTRIBUTES - see db/migrate/20210304014602_create_mock_users.rb etc.
   # ===========================================================================
@@ -8,6 +10,7 @@ class MockUser < ActiveRecord::Base
     primary_key
     scim_uid
     username
+    password
     first_name
     last_name
     work_email_address
@@ -44,6 +47,7 @@ class MockUser < ActiveRecord::Base
       id:         :primary_key,
       externalId: :scim_uid,
       userName:   :username,
+      password:   :password,
       name:       {
         givenName:  :first_name,
         familyName: :last_name

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

@@ -26,6 +26,14 @@ Scimitar.engine_configuration = Scimitar::EngineConfiguration.new({
         before_action :test_hook
       end
     end
+
+    def scim_schemas_url(options)
+      super(test: 1, **options)
+    end
+
+    def scim_resource_type_url(options)
+      super(test: 1, **options)
+    end
   end
 
 })

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

@@ -21,6 +21,11 @@ Rails.application.routes.draw do
   #
   delete 'CustomDestroyUsers/:id', to: 'custom_destroy_mock_users#destroy'
 
+  # For testing blocks passed to ActiveRecordBackedResourcesController#save!
+  #
+  post 'CustomSaveUsers',     to: 'custom_save_mock_users#create'
+  get  'CustomSaveUsers/:id', to: 'custom_save_mock_users#show'
+
   # For testing environment inside Scimitar::ApplicationController subclasses.
   #
   get  'CustomRequestVerifiers', to: 'custom_request_verifiers#index'

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

@@ -7,6 +7,7 @@ class CreateMockUsers < ActiveRecord::Migration[6.1]
       #
       t.text :scim_uid
       t.text :username
+      t.text :password
       t.text :first_name
       t.text :last_name
       t.text :work_email_address

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

@@ -30,10 +30,11 @@ ActiveRecord::Schema.define(version: 2021_03_08_044214) do
   end
 
   create_table "mock_users", primary_key: "primary_key", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t|
-    t.datetime "created_at", precision: 6, null: false
-    t.datetime "updated_at", precision: 6, null: false
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
     t.text "scim_uid"
     t.text "username"
+    t.text "password"
     t.text "first_name"
     t.text "last_name"
     t.text "work_email_address"

data/spec/controllers/scimitar/application_controller_spec.rb

@@ -24,7 +24,7 @@ RSpec.describe Scimitar::ApplicationController do
       get :index, params: { format: :scim }
       expect(response).to be_ok
       expect(JSON.parse(response.body)).to eql({ 'message' => 'cool, cool!' })
-      expect(response.headers['WWW_AUTHENTICATE']).to eql('Basic')
+      expect(response.headers['WWW-Authenticate']).to eql('Basic')
     end
 
     it 'renders failure with bad password' do
@@ -84,7 +84,7 @@ RSpec.describe Scimitar::ApplicationController do
       get :index, params: { format: :scim }
       expect(response).to be_ok
       expect(JSON.parse(response.body)).to eql({ 'message' => 'cool, cool!' })
-      expect(response.headers['WWW_AUTHENTICATE']).to eql('Bearer')
+      expect(response.headers['WWW-Authenticate']).to eql('Bearer')
     end
 
     it 'renders failure with bad token' do

data/spec/controllers/scimitar/resource_types_controller_spec.rb

@@ -9,8 +9,8 @@ RSpec.describe Scimitar::ResourceTypesController do
     it 'renders the resource type for user' do
       get :index, format: :scim
       response_hash = JSON.parse(response.body)
-      expected_response = [ Scimitar::Resources::User.resource_type(scim_resource_type_url(name: 'User')),
-                            Scimitar::Resources::Group.resource_type(scim_resource_type_url(name: 'Group'))
+      expected_response = [ Scimitar::Resources::User.resource_type(scim_resource_type_url(name: 'User', test: 1)),
+                            Scimitar::Resources::Group.resource_type(scim_resource_type_url(name: 'Group', test: 1))
       ].to_json
 
       response_hash = JSON.parse(response.body)

data/spec/controllers/scimitar/schemas_controller_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe Scimitar::SchemasController do
+  routes { Scimitar::Engine.routes }
 
   before(:each) { allow(controller).to receive(:authenticated?).and_return(true) }
 
@@ -26,6 +27,13 @@ RSpec.describe Scimitar::SchemasController do
       expect(parsed_body['name']).to eql('User')
     end
 
+    it 'includes the controller customised schema location' do
+      get :index, params: { name: Scimitar::Schema::User.id, format: :scim }
+      expect(response).to be_ok
+      parsed_body = JSON.parse(response.body)
+      expect(parsed_body.dig('meta', 'location')).to eq scim_schemas_url(name: Scimitar::Schema::User.id, test: 1)
+    end
+
     it 'returns only the Group schema when its id is provided' do
       get :index, params: { name: Scimitar::Schema::Group.id, format: :scim }
       expect(response).to be_ok

data/spec/models/scimitar/lists/query_parser_spec.rb

@@ -405,7 +405,7 @@ RSpec.describe Scimitar::Lists::QueryParser do
       query = @instance.to_activerecord_query(MockUser.all)
 
       expect(query.count).to eql(1)
-      expect(query.pluck(:primary_key)).to eql([user_1.id])
+      expect(query.pluck(:primary_key)).to eql([user_1.primary_key])
 
       @instance.parse('name.givenName sw J') # First name starts with 'J'
       query = @instance.to_activerecord_query(MockUser.all)

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

@@ -14,7 +14,10 @@ RSpec.describe Scimitar::Resources::Base do
           ),
           Scimitar::Schema::Attribute.new(
             name: 'names', multiValued: true, complexType: Scimitar::ComplexTypes::Name, required: false
-          )
+          ),
+          Scimitar::Schema::Attribute.new(
+            name: 'privateName', complexType: Scimitar::ComplexTypes::Name, required: false, returned: false
+          ),
         ]
       end
     end
@@ -30,6 +33,10 @@ RSpec.describe Scimitar::Resources::Base do
             name: {
               givenName:  'John',
               familyName: 'Smith'
+            },
+            privateName: {
+              givenName:  'Alt John',
+              familyName: 'Alt Smith'
             }
           }
 
@@ -39,6 +46,9 @@ RSpec.describe Scimitar::Resources::Base do
           expect(resource.name.is_a?(Scimitar::ComplexTypes::Name)).to be(true)
           expect(resource.name.givenName).to eql('John')
           expect(resource.name.familyName).to eql('Smith')
+          expect(resource.privateName.is_a?(Scimitar::ComplexTypes::Name)).to be(true)
+          expect(resource.privateName.givenName).to eql('Alt John')
+          expect(resource.privateName.familyName).to eql('Alt Smith')
         end
 
         it 'which builds an array of nested resources' do
@@ -101,14 +111,38 @@ RSpec.describe Scimitar::Resources::Base do
     context '#as_json' do
       it 'renders the json with the resourceType' do
         resource = CustomResourse.new(name: {
-          givenName: 'John',
+          givenName:  'John',
           familyName: 'Smith'
         })
 
         result = resource.as_json
-        expect(result['schemas']).to eql(['custom-id'])
+
+        expect(result['schemas']             ).to eql(['custom-id'])
+        expect(result['meta']['resourceType']).to eql('CustomResourse')
+        expect(result['errors']              ).to be_nil
+      end
+
+      it 'excludes attributes that are flagged as do-not-return' do
+        resource = CustomResourse.new(
+          name: {
+            givenName:  'John',
+            familyName: 'Smith'
+          },
+          privateName: {
+            givenName:  'Alt John',
+            familyName: 'Alt Smith'
+          }
+        )
+
+        result = resource.as_json
+
+        expect(result['schemas']             ).to eql(['custom-id'])
         expect(result['meta']['resourceType']).to eql('CustomResourse')
-        expect(result['errors']).to be_nil
+        expect(result['errors']              ).to be_nil
+        expect(result['name']                ).to be_present
+        expect(result['name']['givenName']   ).to eql('John')
+        expect(result['name']['familyName']  ).to eql('Smith')
+        expect(result['privateName']         ).to be_present
       end
     end # "context '#as_json' do"
 

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

@@ -160,13 +160,14 @@ RSpec.describe Scimitar::Resources::Mixin do
 
     context '#to_scim' do
       context 'with a UUID, renamed primary key column' do
-        it 'compiles instance attribute values into a SCIM representation' 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'
@@ -404,6 +405,7 @@ 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'}],
@@ -428,6 +430,7 @@ 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')

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

@@ -42,25 +42,25 @@ RSpec.describe Scimitar::Resources::User do
     let(:user) { described_class.new }
 
     it 'adds the error when the value is a string' do
-      user.add_errors_from_hash({key: 'some error'})
+      user.add_errors_from_hash(errors_hash: {key: 'some error'})
       expect(user.errors.messages.to_h).to eql({key: ['some error']})
       expect(user.errors.full_messages).to eql(['Key some error'])
     end
 
     it 'adds the error when the value is an array' do
-      user.add_errors_from_hash({key: ['error1', 'error2']})
+      user.add_errors_from_hash(errors_hash: {key: ['error1', 'error2']})
       expect(user.errors.messages.to_h).to eql({key: ['error1', 'error2']})
       expect(user.errors.full_messages).to eql(['Key error1', 'Key error2'])
     end
 
     it 'adds the error with prefix when the value is a string' do
-      user.add_errors_from_hash({key: 'some error'}, prefix: :pre)
+      user.add_errors_from_hash(errors_hash: {key: 'some error'}, prefix: :pre)
       expect(user.errors.messages.to_h).to eql({:'pre.key' => ['some error']})
       expect(user.errors.full_messages).to eql(['Pre key some error'])
     end
 
     it 'adds the error wity prefix when the value is an array' do
-      user.add_errors_from_hash({key: ['error1', 'error2']}, prefix: :pre)
+      user.add_errors_from_hash(errors_hash: {key: ['error1', 'error2']}, prefix: :pre)
       expect(user.errors.messages.to_h).to eql({:'pre.key' => ['error1', 'error2']})
       expect(user.errors.full_messages).to eql(['Pre key error1', 'Pre key error2'])
     end

data/spec/models/scimitar/schema/attribute_spec.rb

@@ -46,6 +46,28 @@ RSpec.describe Scimitar::Schema::Attribute do
       expect(attribute.errors.messages.to_h).to eql({userName: ['has the wrong type. It has to be a(n) string.']})
     end
 
+    it 'is valid if multi-valued and type is string and given value is an array of strings' do
+      attribute = described_class.new(name: 'scopes', multiValued: true, type: 'string')
+      expect(attribute.valid?(['something', 'something else'])).to be(true)
+    end
+
+    it 'is valid if multi-valued and type is string and given value is an empty array' do
+      attribute = described_class.new(name: 'scopes', multiValued: true, type: 'string')
+      expect(attribute.valid?([])).to be(true)
+    end
+
+    it 'is invalid if multi-valued and type is string and given value is not an array' do
+      attribute = described_class.new(name: 'scopes', multiValued: true, type: 'string')
+      expect(attribute.valid?('something')).to be(false)
+      expect(attribute.errors.messages.to_h).to eql({scopes: ['or one of its elements has the wrong type. It has to be an array of strings.']})
+    end
+
+    it 'is invalid if multi-valued and type is string and given value is an array containing another type' do
+      attribute = described_class.new(name: 'scopes', multiValued: true, type: 'string')
+      expect(attribute.valid?(['something', 123])).to be(false)
+      expect(attribute.errors.messages.to_h).to eql({scopes: ['or one of its elements has the wrong type. It has to be an array of strings.']})
+    end
+
     it 'is valid if type is boolean and given value is boolean' do
       expect(described_class.new(name: 'name', type: 'boolean').valid?(false)).to be(true)
       expect(described_class.new(name: 'name', type: 'boolean').valid?(true)).to be(true)