scimitar 1.8.1 → 2.0.0

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

@@ -14,10 +14,7 @@ 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
@@ -33,10 +30,6 @@ RSpec.describe Scimitar::Resources::Base do
             name: {
               givenName:  'John',
               familyName: 'Smith'
-            },
-            privateName: {
-              givenName:  'Alt John',
-              familyName: 'Alt Smith'
             }
           }
 
@@ -46,9 +39,6 @@ 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
@@ -111,38 +101,14 @@ 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['name']                ).to be_present
-        expect(result['name']['givenName']   ).to eql('John')
-        expect(result['name']['familyName']  ).to eql('Smith')
-        expect(result['privateName']         ).to be_present
+        expect(result['errors']).to be_nil
       end
     end # "context '#as_json' do"
 
@@ -284,194 +250,90 @@ RSpec.describe Scimitar::Resources::Base do
   end # "context 'dynamic setters based on schema' do"
 
   context 'schema extension' do
-    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') ]
-        end
+    ThirdCustomSchema = Class.new(Scimitar::Schema::Base) do
+      def self.id
+        'custom-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),
-            Scimitar::Schema::Attribute.new(name: "userGroups", multiValued: true, complexType: Scimitar::ComplexTypes::ReferenceGroup, mutability: "writeOnly")
-          ]
-        end
+      def self.scim_attributes
+        [ Scimitar::Schema::Attribute.new(name: 'name', type: 'string') ]
       end
+    end
 
-      let(:resource_class) {
-        Class.new(Scimitar::Resources::Base) do
-          set_schema ThirdCustomSchema
-          extend_schema ExtensionSchema
-
-          def self.endpoint
-            '/gaga'
-          end
-
-          def self.resource_type_id
-            'CustomResource'
-          end
-        end
-      }
-
-      context '#initialize' do
-        it 'allows setting extension attributes' do
-          resource = resource_class.new('extension-id' => {relationship: 'GAGA'})
-          expect(resource.relationship).to eql('GAGA')
-        end
-
-        it 'allows setting complex extension attributes' do
-          user_groups = [{ value: '123' }, { value: '456'}]
-          resource = resource_class.new('extension-id' => {userGroups: user_groups})
-          expect(resource.userGroups.map(&:value)).to eql(['123', '456'])
-        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 '.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 'validation' do
-          it 'validates into custom schema' do
-            resource = resource_class.new('extension-id' => {})
-            expect(resource.valid?).to eql(false)
-
-            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"
+    ExtensionSchema = Class.new(Scimitar::Schema::Base) do
+      def self.id
+        'extension-id'
+      end
 
-      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
+      def self.scim_attributes
+        [ Scimitar::Schema::Attribute.new(name: 'relationship', type: 'string', required: true) ]
+      end
+    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')
-        end
-      end # "context '.find_attribute' do"
-    end # "context 'of custom schema' do"
+    let(:resource_class) {
+      Class.new(Scimitar::Resources::Base) do
+        set_schema ThirdCustomSchema
+        extend_schema ExtensionSchema
 
-    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'
+        def self.endpoint
+          '/gaga'
         end
 
-        def self.scim_attributes
-          [
-            Scimitar::Schema::Attribute.new(name: 'organization', type: 'string'),
-            Scimitar::Schema::Attribute.new(name: 'department',   type: 'string')
-          ]
+        def self.resource_type_id
+          'CustomResource'
         end
       end
+    }
 
-      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'})
+    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"
 
-          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(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 '#as_json' do
-        it 'namespaces the extension attributes' do
-          resource = resource_class.new(organization: 'SOMEORG', department: 'SOMEDPT')
-          hash = resource.as_json
+    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
 
-          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 '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://example.com')
-          expect(resource_type.meta.location).to eql('http://example.com')
-          expect(resource_type.schemaExtensions.count).to eql(1)
+          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('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
+    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
 
-        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"
+      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 '.find_attribute' do"
   end # "context 'schema extension' do"
 end

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

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe Scimitar::Resources::Base do
+
   context '#valid?' do
     MyCustomSchema = Class.new(Scimitar::Schema::Base) do
       def self.id
@@ -20,9 +21,6 @@ RSpec.describe Scimitar::Resources::Base do
           ),
           Scimitar::Schema::Attribute.new(
             name: 'complexNames', complexType: Scimitar::ComplexTypes::Name, multiValued:true, required: false
-          ),
-          Scimitar::Schema::Attribute.new(
-            name: 'vdtpTestByEmail', complexType: Scimitar::ComplexTypes::Email, required: false
           )
         ]
       end
@@ -59,28 +57,5 @@ RSpec.describe Scimitar::Resources::Base do
       expect(resource.valid?).to be(false)
       expect(resource.errors.full_messages).to match_array(["Complexnames has to follow the complexType format.", "Complexnames familyname has the wrong type. It has to be a(n) string."])
     end
-
-    context 'configuration of required values in VDTP schema' do
-      around :each do | example |
-        original_configuration = Scimitar.engine_configuration.optional_value_fields_required
-        Scimitar::Schema::Email.instance_variable_set('@scim_attributes', nil)
-        example.run()
-      ensure
-        Scimitar.engine_configuration.optional_value_fields_required = original_configuration
-        Scimitar::Schema::Email.instance_variable_set('@scim_attributes', nil)
-      end
-
-      it 'requires a value by default' do
-        resource = MyCustomResource.new(vdtpTestByEmail: { value: nil }, enforce: false)
-        expect(resource.valid?).to be(false)
-        expect(resource.errors.full_messages).to match_array(['Vdtptestbyemail value is required'])
-      end
-
-      it 'can be configured for optional values' do
-        Scimitar.engine_configuration.optional_value_fields_required = false
-        resource = MyCustomResource.new(vdtpTestByEmail: { value: nil }, enforce: false)
-        expect(resource.valid?).to be(true)
-      end
-    end # "context 'configuration of required values in VDTP schema' do"
-  end # "context '#valid?' do"
+  end
 end