scimitar 1.8.2 → 2.0.0

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

@@ -10,7 +10,6 @@ module Scimitar
       def self.scim_attributes
         @scim_attributes ||= [
           Attribute.new(name: 'type',          type: 'string'),
-          Attribute.new(name: 'primary',       type: 'boolean'),
           Attribute.new(name: 'formatted',     type: 'string'),
           Attribute.new(name: 'streetAddress', type: 'string'),
           Attribute.new(name: 'locality',      type: 'string'),

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

@@ -93,23 +93,14 @@ module Scimitar
       end
 
       def valid_simple_type?(value)
-        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 = (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
         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

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

@@ -7,7 +7,7 @@ module Scimitar
     class Vdtp < Base
       def self.scim_attributes
         @scim_attributes ||= [
-          Attribute.new(name: 'value',   type: 'string', required: Scimitar.engine_configuration.optional_value_fields_required),
+          Attribute.new(name: 'value',   type: 'string', required: true),
           Attribute.new(name: 'display', type: 'string', mutability: 'readOnly'),
           Attribute.new(name: 'type',    type: 'string'),
           Attribute.new(name: 'primary', type: 'boolean'),

data/app/models/scimitar/service_provider_configuration.rb

@@ -9,22 +9,11 @@ module Scimitar
   class ServiceProviderConfiguration
     include ActiveModel::Model
 
-    attr_accessor(
-      :uses_defaults,
-      :patch,
-      :bulk,
-      :filter,
-      :changePassword,
-      :sort,
-      :etag,
-      :authenticationSchemes,
-      :schemas,
-      :meta,
-    )
+    attr_accessor :patch, :bulk, :filter, :changePassword,
+      :sort, :etag, :authenticationSchemes,
+      :schemas, :meta
 
     def initialize(attributes = {})
-      @uses_defaults = attributes.empty?
-
       defaults = {
         bulk:           Supportable.unsupported,
         changePassword: Supportable.unsupported,

data/config/initializers/scimitar.rb

@@ -38,10 +38,9 @@ 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. 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:
+    # 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:
     #
     #     application_controller_mixin: Module.new do
     #       def self.included(base)
@@ -55,10 +54,6 @@ 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:
@@ -86,26 +81,6 @@ Rails.application.config.to_prepare do # (required for >= Rails 7 / Zeitwerk)
     # Note that both basic and token authentication can be declared, with the
     # parameters in the inbound HTTP request determining which is invoked.
 
-    # Scimitar rescues certain error cases and exceptions, in order to return a
-    # JSON response to the API caller. If you want exceptions to also be
-    # reported to a third party system such as sentry.io or raygun.com, you can
-    # configure a Proc to do so. It is passed a Ruby exception subclass object.
-    # For example, a minimal sentry.io reporter might do this:
-    #
-    #     exception_reporter: Proc.new do | exception |
-    #       Sentry.capture_exception(exception)
-    #     end
-    #
-    # You will still need to configure your reporting system according to its
-    # documentation (e.g. via a Rails "config/initializers/<foo>.rb" file).
-
-    # Scimilar treats "VDTP" (Value, Display, Type, Primary) attribute values,
-    # used for e.g. e-mail addresses or phone numbers, as required by default.
-    # If you encounter a service which calls these with e.g. "null" value data,
-    # you can configure all values to be optional. You'll need to deal with
-    # whatever that means for you receiving system in your model code.
-    #
-    #     optional_value_fields_required: false
   })
 
 end

data/lib/scimitar/support/hash_with_indifferent_case_insensitive_access.rb

@@ -23,8 +23,8 @@ class Hash
   #
   def self.deep_indifferent_case_insensitive_access(object)
     if object.is_a?(Hash)
-      new_hash = Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess.new
-      object.each do | key, value |
+      new_hash = Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess.new(object)
+      new_hash.each do | key, value |
         new_hash[key] = deep_indifferent_case_insensitive_access(value)
       end
       new_hash
@@ -49,164 +49,34 @@ module Scimitar
     # in a case-insensitive fashion too.
     #
     # During enumeration, Hash keys will always be returned in whatever case
-    # they were originally set. Just as with
-    # ActiveSupport::HashWithIndifferentAccess, though, the type of the keys is
-    # always returned as a String, even if originally set as a Symbol - only
-    # the upper/lower case nature of the original key is preserved.
-    #
-    # If a key is written more than once with the same effective meaning in a
-    # to-string, to-downcase form, then whatever case was used *first* wins;
-    # e.g. if you did hash['User'] = 23, then hash['USER'] = 42, the result
-    # would be {"User" => 42}.
-    #
-    # It's important to remember that Hash#merge is shallow and replaces values
-    # found at existing keys in the target ("this") hash with values in the
-    # inbound Hash. If that new value that is itself a Hash, this *replaces*
-    # the value. For example:
-    #
-    # * Original: <tt>'Foo' => { 'Bar' => 42 }</tt>
-    # * Merge:    <tt>'FOO' => { 'BAR' => 24 }</tt>
-    #
-    # ...results in "this" target hash's key +Foo+ being addressed in the merge
-    # by inbound key +FOO+, so the case doesn't change. But the value for +Foo+
-    # is _replaced_ by the merging-in Hash completely:
-    #
-    # * Result: <tt>'Foo' => { 'BAR' => 24 }</tt>
-    #
-    # ...and of course we might've replaced with a totally different type, such
-    # as +true+:
-    #
-    # * Original: <tt>'Foo' => { 'Bar' => 42 }</tt>
-    # * Merge:    <tt>'FOO' => true</tt>
-    # * Result:   <tt>'Foo' => true</tt>
-    #
-    # If you're intending to merge nested Hashes, then use ActiveSupport's
-    # #deep_merge or an equivalent. This will have the expected outcome, where
-    # the hash with 'BAR' is _merged_ into the existing value and, therefore,
-    # the original 'Bar' key case is preserved:
-    #
-    # * Original:   <tt>'Foo' => { 'Bar' => 42 }</tt>
-    # * Deep merge: <tt>'FOO' => { 'BAR' => 24 }</tt>
-    # * Result:     <tt>'Foo' => { 'Bar' => 24 }</tt>
+    # they were originally set.
     #
     class HashWithIndifferentCaseInsensitiveAccess < ActiveSupport::HashWithIndifferentAccess
       def with_indifferent_case_insensitive_access
         self
       end
 
-      def initialize(constructor = nil)
-        @scimitar_hash_with_indifferent_case_insensitive_access_key_map = {}
-        super
-      end
-
-      # It's vital that the attribute map is carried over when one of these
-      # objects is duplicated. Duplication of this ivar state does *not* happen
-      # when 'dup' is called on our superclass, so we have to do that manually.
-      #
-      def dup
-        duplicate = super
-        duplicate.instance_variable_set(
-          '@scimitar_hash_with_indifferent_case_insensitive_access_key_map',
-          @scimitar_hash_with_indifferent_case_insensitive_access_key_map
-        )
-
-        return duplicate
-      end
-
-      # Override the individual key writer.
-      #
-      def []=(key, value)
-        string_key      = scimitar_hash_with_indifferent_case_insensitive_access_string(key)
-        indifferent_key = scimitar_hash_with_indifferent_case_insensitive_access_downcase(string_key)
-        converted_value = convert_value(value, conversion: :assignment)
-
-        # Note '||=', as there might have been a prior use of the "same" key in
-        # a different case. The earliest one is preserved since the actual Hash
-        # underneath all this is already using that variant of the key.
-        #
-        key_for_writing = (
-          @scimitar_hash_with_indifferent_case_insensitive_access_key_map[indifferent_key] ||= string_key
-        )
-
-        regular_writer(key_for_writing, converted_value)
-      end
-
-      # Override #merge to express it in terms of #merge! (also overridden), so
-      # that merged hashes can have their keys treated indifferently too.
-      #
-      def merge(*other_hashes, &block)
-        dup.merge!(*other_hashes, &block)
-      end
-
-      # Modifies-self version of #merge, overriding Hash#merge!.
-      #
-      def merge!(*hashes_to_merge_to_self, &block)
-        if block_given?
-          hashes_to_merge_to_self.each do |hash_to_merge_to_self|
-            hash_to_merge_to_self.each_pair do |key, value|
-              value = block.call(key, self[key], value) if self.key?(key)
-              self[key] = value
-            end
-          end
-        else
-          hashes_to_merge_to_self.each do |hash_to_merge_to_self|
-            hash_to_merge_to_self.each_pair do |key, value|
-              self[key] = value
-            end
-          end
-        end
-
-        self
-      end
-
-      # =======================================================================
-      # PRIVATE INSTANCE METHODS
-      # =======================================================================
-      #
       private
 
         if Symbol.method_defined?(:name)
-          def scimitar_hash_with_indifferent_case_insensitive_access_string(key)
-            key.kind_of?(Symbol) ? key.name : key
+          def convert_key(key)
+            key.kind_of?(Symbol) ? key.name.downcase : key.downcase
           end
         else
-          def scimitar_hash_with_indifferent_case_insensitive_access_string(key)
-            key.kind_of?(Symbol) ? key.to_s : key
-          end
-        end
-
-        def scimitar_hash_with_indifferent_case_insensitive_access_downcase(key)
-          key.kind_of?(String) ? key.downcase : key
-        end
-
-        def convert_key(key)
-          string_key      = scimitar_hash_with_indifferent_case_insensitive_access_string(key)
-          indifferent_key = scimitar_hash_with_indifferent_case_insensitive_access_downcase(string_key)
-
-          @scimitar_hash_with_indifferent_case_insensitive_access_key_map[indifferent_key] || string_key
-        end
-
-        def convert_value(value, conversion: nil)
-          if value.is_a?(Hash)
-            if conversion == :to_hash
-              value.to_hash
-            else
-              value.with_indifferent_case_insensitive_access
-            end
-          else
-            super
+          def convert_key(key)
+            key.kind_of?(Symbol) ? key.to_s.downcase : key.downcase
           end
         end
 
         def update_with_single_argument(other_hash, block)
-          if other_hash.is_a?(HashWithIndifferentCaseInsensitiveAccess)
+          if other_hash.is_a? HashWithIndifferentCaseInsensitiveAccess
             regular_update(other_hash, &block)
           else
             other_hash.to_hash.each_pair do |key, value|
               if block && key?(key)
-                value = block.call(self.convert_key(key), self[key], value)
+                value = block.call(convert_key(key), self[key], value)
               end
-              self.[]=(key, value)
+              regular_writer(convert_key(key), convert_value(value))
             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.8.2'
+  VERSION = '2.0.0'
 
   # Date for VERSION. If this changes, be sure to re-run "bundle install"
   # or "bundle update".
   #
-  DATE = '2024-03-27'
+  DATE = '2022-03-04'
 
 end

data/lib/scimitar.rb

@@ -1,13 +1,10 @@
 require 'scimitar/version'
 require 'scimitar/support/hash_with_indifferent_case_insensitive_access'
-require 'scimitar/support/utilities'
 require 'scimitar/engine'
 
 module Scimitar
   def self.service_provider_configuration=(custom_configuration)
-    if @service_provider_configuration.nil? || ! custom_configuration.uses_defaults
-      @service_provider_configuration = custom_configuration
-    end
+    @service_provider_configuration = custom_configuration
   end
 
   def self.service_provider_configuration(location:)
@@ -17,9 +14,7 @@ module Scimitar
   end
 
   def self.engine_configuration=(custom_configuration)
-    if @engine_configuration.nil? || ! custom_configuration.uses_defaults
-      @engine_configuration = custom_configuration
-    end
+    @engine_configuration = custom_configuration
   end
 
   def self.engine_configuration

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

@@ -1,4 +1,4 @@
-class MockGroupsController < Scimitar::ActiveRecordBackedResourcesController
+class MockUsersController < Scimitar::ActiveRecordBackedResourcesController
 
   protected
 

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

@@ -58,7 +58,7 @@ class MockGroup < ActiveRecord::Base
 
           case type.downcase
             when 'user'
-              MockUser.find_by_primary_key(id)
+              MockUser.find_by_id(id)
             when 'group'
               MockGroup.find_by_id(id)
             else

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

@@ -1,24 +1,18 @@
 class MockUser < ActiveRecord::Base
 
-  self.primary_key = :primary_key
-
   # ===========================================================================
   # TEST ATTRIBUTES - see db/migrate/20210304014602_create_mock_users.rb etc.
   # ===========================================================================
 
   READWRITE_ATTRS = %w{
-    primary_key
+    id
     scim_uid
     username
-    password
     first_name
     last_name
     work_email_address
     home_email_address
     work_phone_number
-    organization
-    department
-    mock_groups
   }
 
   has_and_belongs_to_many :mock_groups
@@ -44,10 +38,9 @@ class MockUser < ActiveRecord::Base
 
   def self.scim_attributes_map
     return {
-      id:         :primary_key,
+      id:         :id,
       externalId: :scim_uid,
       userName:   :username,
-      password:   :password,
       name:       {
         givenName:  :first_name,
         familyName: :last_name
@@ -89,23 +82,7 @@ class MockUser < ActiveRecord::Base
           }
         }
       ],
-      active: :is_active,
-
-      # Custom extension schema - see configuration in
-      # "spec/apps/dummy/config/initializers/scimitar.rb".
-      #
-      organization: :organization,
-      department:   :department,
-      userGroups: [
-        {
-          list:      :mock_groups,
-          find_with: ->(value) { MockGroup.find(value["value"]) },
-          using: {
-            value:   :id,
-            display: :display_name
-          }
-        }
-      ]
+      active: :is_active
     }
   end
 
@@ -115,16 +92,11 @@ class MockUser < ActiveRecord::Base
 
   def self.scim_queryable_attributes
     return {
-      'id'                => { column: :primary_key },
-      'externalId'        => { column: :scim_uid },
-      'meta.lastModified' => { column: :updated_at },
-      'name.givenName'    => { column: :first_name },
-      'name.familyName'   => { column: :last_name  },
-      'groups'            => { column: MockGroup.arel_table[:id] },
-      'groups.value'      => { column: MockGroup.arel_table[:id] },
-      'emails'            => { columns: [ :work_email_address, :home_email_address ] },
-      'emails.value'      => { columns: [ :work_email_address, :home_email_address ] },
-      'emails.type'       => { ignore: true } # We can't filter on that; it'll just search all e-mails
+      'name.givenName'  => { column: :first_name },
+      'name.familyName' => { column: :last_name  },
+      'emails'          => { columns: [ :work_email_address, :home_email_address ] },
+      'emails.value'    => { columns: [ :work_email_address, :home_email_address ] },
+      'emails.type'     => { ignore: true } # We can't filter on that; it'll just search all e-mails
     }
   end
 

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

@@ -12,6 +12,7 @@ require 'scimitar'
 
 module Dummy
   class Application < Rails::Application
+    config.load_defaults 7.0
   end
 end
 

data/spec/apps/dummy/config/environments/test.rb

@@ -1,15 +1,38 @@
+require 'active_support/core_ext/integer/time'
+
 Rails.application.configure do
   config.cache_classes = true
   config.eager_load = false
-  config.serve_static_files = true
-  config.static_cache_control = 'public, max-age=3600'
-  config.consider_all_requests_local = true
 
-  config.action_dispatch.show_exceptions = false
+  # Configure public file server for tests with Cache-Control for performance.
+  config.public_file_server.enabled = true
+  config.public_file_server.headers = {
+    'Cache-Control' => "public, max-age=#{1.hour.to_i}"
+  }
 
+  # Show full error reports and disable caching.
+  config.consider_all_requests_local       = true
   config.action_controller.perform_caching = false
+  config.cache_store = :null_store
+
+  # Raise exceptions instead of rendering exception templates.
+  config.action_dispatch.show_exceptions = false
+
+  # Disable request forgery protection in test environment.
   config.action_controller.allow_forgery_protection = false
 
-  config.active_support.test_order = :random
+  # Print deprecation notices to the stderr.
   config.active_support.deprecation = :stderr
+
+  # Raise exceptions for disallowed deprecations.
+  config.active_support.disallowed_deprecation = :raise
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Raises error for missing translations.
+  config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
 end

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

@@ -1,67 +1,16 @@
 # 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.
-#
-# Further, https://github.com/RIPAGlobal/scimitar/pull/54 fixed warning
-# messages in a way that worked on Rails 6+ but, for V1 Scimitar, it would
-# break existing working setups that didn't use the +to_prepare+ wrapper. Their
-# application configuration would be written *first* but then *overwritten* by
-# the default +to_prepare+ block in Scimitar itself, since that runs later. The
-# file below does *not* use +to_prepare+ in order to test the workaround that
-# was produced; it should work on all Ruby versions as-is.
-#
-Scimitar.engine_configuration = Scimitar::EngineConfiguration.new({
-
-  application_controller_mixin: Module.new do
-    def self.included(base)
-      base.class_eval do
-        def test_hook; end
-        before_action :test_hook
+Rails.application.config.to_prepare do
+  Scimitar.engine_configuration = Scimitar::EngineConfiguration.new({
+
+    application_controller_mixin: Module.new do
+      def self.included(base)
+        base.class_eval do
+          def test_hook; end
+          before_action :test_hook
+        end
       end
     end
 
-    def scim_schemas_url(options)
-      super(test: 1, **options)
-    end
-
-    def scim_resource_type_url(options)
-      super(test: 1, **options)
-    end
-  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

@@ -6,38 +6,17 @@
 Rails.application.routes.draw do
   mount Scimitar::Engine, at: '/'
 
-  get    'Users',      to: 'mock_users#index'
-  get    'Users/:id',  to: 'mock_users#show'
-  post   'Users',      to: 'mock_users#create'
-  put    'Users/:id',  to: 'mock_users#replace'
-  patch  'Users/:id',  to: 'mock_users#update'
-  delete 'Users/:id',  to: 'mock_users#destroy'
+  get    'Users',     to: 'mock_users#index'
+  get    'Users/:id', to: 'mock_users#show'
+  post   'Users',     to: 'mock_users#create'
+  put    'Users/:id', to: 'mock_users#replace'
+  patch  'Users/:id', to: 'mock_users#update'
+  delete 'Users/:id', to: 'mock_users#destroy'
 
-  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#create,
-  # #update, #replace and #destroy.
+  # For testing blocks passed to ActiveRecordBackedResourcesController#destroy
   #
-  post   'CustomCreateUsers',      to: 'custom_create_mock_users#create'
-  patch  'CustomUpdateUsers/:id',  to: 'custom_update_mock_users#update'
-  put    'CustomReplaceUsers/:id', to: 'custom_replace_mock_users#replace'
   delete 'CustomDestroyUsers/:id', to: 'custom_destroy_mock_users#destroy'
 
-  # Needed because the auto-render of most of the above includes a 'url_for'
-  # call for a 'show' action, so we must include routes (implemented in the
-  # base class) for the "show" endpoint.
-  #
-  get  'CustomCreateUsers/:id',  to: 'custom_create_mock_users#show'
-  get  'CustomUpdateUsers/:id',  to: 'custom_update_mock_users#show'
-  get  'CustomReplaceUsers/:id', to: 'custom_replace_mock_users#show'
-
-  # 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

@@ -1,24 +1,15 @@
 class CreateMockUsers < ActiveRecord::Migration[6.1]
   def change
-    create_table :mock_users, id: :uuid, primary_key: :primary_key do |t|
-      t.timestamps
+    create_table :mock_users do |t|
 
-      # Support part of the core schema
-      #
       t.text :scim_uid
       t.text :username
-      t.text :password
       t.text :first_name
       t.text :last_name
       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