scimitar 1.10.0 → 2.0.0

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

@@ -60,15 +60,6 @@ RSpec.describe Scimitar::Lists::QueryParser do
       expect(%Q("O'Malley")).to eql(tree[2])
     end
 
-    it "extended attribute equals" do
-      @instance.parse(%Q(primaryEmail eq "foo@bar.com"))
-
-      rpn = @instance.rpn
-      expect('primaryEmail').to eql(rpn[0])
-      expect(%Q("foo@bar.com")).to eql(rpn[1])
-      expect('eq').to eql(rpn[2])
-    end
-
     it "user name starts with" do
       @instance.parse(%Q(userName sw "J"))
 
@@ -346,67 +337,6 @@ RSpec.describe Scimitar::Lists::QueryParser do
         result = @instance.send(:flatten_filter, 'emails[type eq "work" and value co "@example.com"    ] or userType eq "Admin" or ims[type eq "xmpp" and value co "@foo.com"]')
         expect(result).to eql('emails.type eq "work" and emails.value co "@example.com" or userType eq "Admin" or ims.type eq "xmpp" and ims.value co "@foo.com"')
       end
-
-      it 'handles an example previously described as unsupported in README.md' do
-        result = @instance.send(:flatten_filter, 'filter=userType eq "Employee" and emails[type eq "work" and value co "@example.com"]')
-        expect(result).to eql('filter=userType eq "Employee" and emails.type eq "work" and emails.value co "@example.com"')
-      end
-
-      # https://github.com/RIPAGlobal/scimitar/issues/116
-      #
-      context 'with schema IDs (GitHub issue #116)' do
-        it 'handles simple attributes' do
-          result = @instance.send(:flatten_filter, 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:employeeId eq "gsar"')
-          expect(result).to eql('employeeId eq "gsar"')
-        end
-
-        it 'handles dotted attribute paths' do
-          result = @instance.send(:flatten_filter, 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:imaginary.path eq "gsar"')
-          expect(result).to eql('imaginary.path eq "gsar"')
-        end
-
-        it 'replaces all examples' do
-          result = @instance.send(:flatten_filter, 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:employeeId eq "gsar" or urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:imaginary.path eq "gsar"')
-          expect(result).to eql('employeeId eq "gsar" or imaginary.path eq "gsar"')
-        end
-
-        it 'handles the square bracket form with schema ID at the root' do
-          result = @instance.send(:flatten_filter, 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User[employeeId eq "gsar"')
-          expect(result).to eql('employeeId eq "gsar"')
-        end
-
-        it 'handles the square bracket form with schema ID and attribute at the root' do
-          result = @instance.send(:flatten_filter, 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:imaginary[path eq "gsar"')
-          expect(result).to eql('imaginary.path eq "gsar"')
-        end
-      end
-
-      # https://github.com/RIPAGlobal/scimitar/issues/115
-      #
-      context 'broken filters from Microsoft (GitHub issue #115)' do
-        it 'work with "eq"' do
-          result = @instance.send(:flatten_filter, 'emails[type eq "work"].value eq "foo@bar.com"')
-          expect(result).to eql('emails.type eq "work" and emails.value eq "foo@bar.com"')
-        end
-
-        it 'work with "ne"' do # (just check a couple of operators, not all!)
-          result = @instance.send(:flatten_filter, 'emails[type eq "work"].value ne "foo@bar.com"')
-          expect(result).to eql('emails.type eq "work" and emails.value ne "foo@bar.com"')
-        end
-
-        it 'preserve input case' do
-          result = @instance.send(:flatten_filter, 'emaiLs[TYPE eq "work"].valUE eq "FOO@bar.com"')
-          expect(result).to eql('emaiLs.TYPE eq "work" and emaiLs.valUE eq "FOO@bar.com"')
-        end
-
-        # At the time of writing, this was used in a "belt and braces" request
-        # spec in 'active_record_backed_resources_controller_spec.rb'.
-        #
-        it 'handles more complex, hypothetical cases' do
-          result = @instance.send(:flatten_filter, 'name[givenName eq "FOO"].familyName pr and emails ne "home_1@test.com"')
-          expect(result).to eql('name.givenName eq "FOO" and name.familyName pr and emails ne "home_1@test.com"')
-        end
-      end # "context 'broken filters from Microsoft' do"
     end # "context 'when flattening is needed' do"
 
     context 'with bad filters' do
@@ -475,19 +405,19 @@ 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.primary_key])
+      expect(query.pluck(:id)).to eql([user_1.id])
 
       @instance.parse('name.givenName sw J') # First name starts with 'J'
       query = @instance.to_activerecord_query(MockUser.all)
 
       expect(query.count).to eql(2)
-      expect(query.pluck(:primary_key)).to match_array([user_1.primary_key, user_2.primary_key])
+      expect(query.pluck(:id)).to match_array([user_1.id, user_2.id])
 
       @instance.parse('name.familyName ew he') # Last name ends with 'he'
       query = @instance.to_activerecord_query(MockUser.all)
 
       expect(query.count).to eql(1)
-      expect(query.pluck(:primary_key)).to eql([user_2.primary_key])
+      expect(query.pluck(:id)).to eql([user_2.id])
 
       # Test presence
 
@@ -495,7 +425,7 @@ RSpec.describe Scimitar::Lists::QueryParser do
       query = @instance.to_activerecord_query(MockUser.all)
 
       expect(query.count).to eql(2)
-      expect(query.pluck(:primary_key)).to match_array([user_1.primary_key, user_2.primary_key])
+      expect(query.pluck(:id)).to match_array([user_1.id, user_2.id])
 
       # Test a simple not-equals, but use a custom starting scope. Note that
       # the query would find "user_3" *except* there is no first name defined
@@ -505,7 +435,7 @@ RSpec.describe Scimitar::Lists::QueryParser do
       query = @instance.to_activerecord_query(MockUser.where.not('first_name' => 'John'))
 
       expect(query.count).to eql(1)
-      expect(query.pluck(:primary_key)).to match_array([user_1.primary_key])
+      expect(query.pluck(:id)).to match_array([user_1.id])
     end
 
     context 'when mapped to multiple columns' do
@@ -551,66 +481,6 @@ RSpec.describe Scimitar::Lists::QueryParser do
       end
     end # "context 'when instructed to ignore an attribute' do"
 
-    context 'when an arel column is mapped' do
-      let(:scope_with_groups) { MockUser.left_joins(:mock_groups) }
-
-      context 'with binary operators' do
-        it 'reads across all using OR' do
-          @instance.parse('groups eq "12345"')
-          query = @instance.to_activerecord_query(scope_with_groups)
-
-          expect(query.to_sql).to eql(<<~SQL.squish)
-            SELECT "mock_users".*
-            FROM "mock_users"
-              LEFT OUTER JOIN "mock_groups_users" ON "mock_groups_users"."mock_user_id" = "mock_users"."primary_key"
-              LEFT OUTER JOIN "mock_groups" ON "mock_groups"."id" = "mock_groups_users"."mock_group_id"
-            WHERE "mock_groups"."id" ILIKE 12345
-          SQL
-        end
-
-        it 'works with other query elements using correct precedence' do
-          @instance.parse('groups eq "12345" and emails eq "any@test.com"')
-          query = @instance.to_activerecord_query(scope_with_groups)
-
-          expect(query.to_sql).to eql(<<~SQL.squish)
-            SELECT "mock_users".*
-            FROM "mock_users"
-              LEFT OUTER JOIN "mock_groups_users" ON "mock_groups_users"."mock_user_id" = "mock_users"."primary_key"
-              LEFT OUTER JOIN "mock_groups" ON "mock_groups"."id" = "mock_groups_users"."mock_group_id"
-            WHERE "mock_groups"."id" ILIKE 12345 AND ("mock_users"."work_email_address" ILIKE 'any@test.com' OR "mock_users"."home_email_address" ILIKE 'any@test.com')
-          SQL
-        end
-      end # "context 'with binary operators' do"
-
-      context 'with unary operators' do
-        it 'reads across all using OR' do
-          @instance.parse('groups pr')
-          query = @instance.to_activerecord_query(scope_with_groups)
-
-          expect(query.to_sql).to eql(<<~SQL.squish)
-            SELECT "mock_users".*
-            FROM "mock_users"
-              LEFT OUTER JOIN "mock_groups_users" ON "mock_groups_users"."mock_user_id" = "mock_users"."primary_key"
-              LEFT OUTER JOIN "mock_groups" ON "mock_groups"."id" = "mock_groups_users"."mock_group_id"
-            WHERE ("mock_groups"."id" != NULL AND "mock_groups"."id" IS NOT NULL)
-          SQL
-        end
-
-        it 'works with other query elements using correct precedence' do
-          @instance.parse('name.familyName eq "John" and groups pr')
-          query = @instance.to_activerecord_query(scope_with_groups)
-
-          expect(query.to_sql).to eql(<<~SQL.squish)
-            SELECT "mock_users".*
-            FROM "mock_users"
-              LEFT OUTER JOIN "mock_groups_users" ON "mock_groups_users"."mock_user_id" = "mock_users"."primary_key"
-              LEFT OUTER JOIN "mock_groups" ON "mock_groups"."id" = "mock_groups_users"."mock_group_id"
-            WHERE "mock_users"."last_name" ILIKE 'John' AND ("mock_groups"."id" != NULL AND "mock_groups"."id" IS NOT NULL)
-          SQL
-        end
-      end # "context 'with unary operators' do
-    end # "context 'when an arel column is mapped' do"
-
     context 'with complex cases' do
       context 'using AND' do
         it 'generates expected SQL' do
@@ -629,7 +499,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 match_array([user_2.primary_key])
+          expect(query.pluck(:id)).to match_array([user_2.id])
         end
       end # "context 'simple AND' do"
 
@@ -650,7 +520,7 @@ RSpec.describe Scimitar::Lists::QueryParser do
           query = @instance.to_activerecord_query(MockUser.all)
 
           expect(query.count).to eql(2)
-          expect(query.pluck(:primary_key)).to match_array([user_1.primary_key, user_2.primary_key])
+          expect(query.pluck(:id)).to match_array([user_1.id, user_2.id])
         end
       end # "context 'simple OR' do"
 
@@ -662,13 +532,6 @@ RSpec.describe Scimitar::Lists::QueryParser do
           expect(query.to_sql).to eql(%q{SELECT "mock_users".* FROM "mock_users" WHERE "mock_users"."first_name" ILIKE 'Jane' AND ("mock_users"."last_name" ILIKE '%avi%' OR "mock_users"."last_name" ILIKE '%ith')})
         end
 
-        it 'combined parentheses generates expected SQL' do
-          @instance.parse('(name.givenName eq "Jane" OR name.givenName eq "Jaden") and (name.familyName co "avi" or name.familyName ew "ith")')
-          query = @instance.to_activerecord_query(MockUser.all)
-
-          expect(query.to_sql).to eql(%q{SELECT "mock_users".* FROM "mock_users" WHERE ("mock_users"."first_name" ILIKE 'Jane' OR "mock_users"."first_name" ILIKE 'Jaden') AND ("mock_users"."last_name" ILIKE '%avi%' OR "mock_users"."last_name" ILIKE '%ith')})
-        end
-
         it 'finds expected items' do
           user_1 = MockUser.create(username: '1', first_name: 'Jane', last_name: 'Davis')   # Match
           user_2 = MockUser.create(username: '2', first_name: 'Jane', last_name: 'Smith')   # Match
@@ -683,7 +546,7 @@ RSpec.describe Scimitar::Lists::QueryParser do
           query = @instance.to_activerecord_query(MockUser.all)
 
           expect(query.count).to eql(3)
-          expect(query.pluck(:primary_key)).to match_array([user_1.primary_key, user_2.primary_key, user_3.primary_key])
+          expect(query.pluck(:id)).to match_array([user_1.id, user_2.id, user_3.id])
         end
       end # "context 'combined AND and OR' do"
 
@@ -727,7 +590,7 @@ RSpec.describe Scimitar::Lists::QueryParser do
       end
 
       it 'complains if there is no column mapping available' do
-        expect { @instance.send(:activerecord_columns, 'userName') }.to raise_error(Scimitar::FilterError)
+        expect { @instance.send(:activerecord_columns, 'externalId') }.to raise_error(Scimitar::FilterError)
       end
 
       it 'complains about malformed declarations' do

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

@@ -4,7 +4,7 @@ RSpec.describe Scimitar::Resources::Base do
   context 'basic operation' do
     FirstCustomSchema = Class.new(Scimitar::Schema::Base) do
       def self.id
-        'urn:ietf:params:scim:schemas:custom-id'
+        'custom-id'
       end
 
       def self.scim_attributes
@@ -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: 'never'
-          ),
+          )
         ]
       end
     end
@@ -27,24 +24,12 @@ RSpec.describe Scimitar::Resources::Base do
     end
 
     context '#initialize' do
-      it 'accepts nil for non-required attributes' do
-        resource = CustomResourse.new(name: nil, names: nil, privateName: nil)
-
-        expect(resource.name).to be_nil
-        expect(resource.names).to be_nil
-        expect(resource.privateName).to be_nil
-      end
-
       shared_examples 'an initializer' do | force_upper_case: |
         it 'which builds the nested type' do
           attributes = {
             name: {
               givenName:  'John',
               familyName: 'Smith'
-            },
-            privateName: {
-              givenName:  'Alt John',
-              familyName: 'Alt Smith'
             }
           }
 
@@ -54,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
@@ -119,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(['urn:ietf:params:scim:schemas: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(['urn:ietf:params:scim:schemas: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"
 
@@ -292,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
-          'urn:ietf:params:scim:schemas: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
-          'urn:ietf:params:scim:schemas:extension'
-        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('urn:ietf:params:scim:schemas:extension' => {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('urn:ietf:params:scim:schemas:extension' => {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(['urn:ietf:params:scim:schemas:custom-id', 'urn:ietf:params:scim:schemas:extension'])
-          expect(hash["urn:ietf:params:scim:schemas:extension"]).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('urn:ietf:params:scim:schemas:extension' => {})
-            expect(resource.valid?).to eql(false)
-
-            resource = resource_class.new('urn:ietf:params:scim:schemas:extension' => {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,23 +1,11 @@
 require 'spec_helper'
 
 RSpec.describe Scimitar::Resources::Base do
+
   context '#valid?' do
     MyCustomSchema = Class.new(Scimitar::Schema::Base) do
       def self.id
-        'urn:ietf:params:scim:schemas:custom-id'
-      end
-
-      class NameWithRequirementsSchema < Scimitar::Schema::Base
-        def self.scim_attributes
-          @scim_attributes ||= [
-            Scimitar::Schema::Attribute.new(name: 'familyName', type: 'string', required: true),
-            Scimitar::Schema::Attribute.new(name: 'givenName',  type: 'string', required: true),
-          ]
-        end
-      end
-
-      class NameWithRequirementsComplexType < Scimitar::ComplexTypes::Base
-        set_schema NameWithRequirementsSchema
+        'custom-id'
       end
 
       def self.scim_attributes
@@ -29,13 +17,10 @@ RSpec.describe Scimitar::Resources::Base do
             name: 'enforce', type: 'boolean', required: true
           ),
           Scimitar::Schema::Attribute.new(
-            name: 'complexName', complexType: NameWithRequirementsComplexType, required: false
-          ),
-          Scimitar::Schema::Attribute.new(
-            name: 'complexNames', complexType: Scimitar::ComplexTypes::Name, multiValued: true, required: false
+            name: 'complexName', complexType: Scimitar::ComplexTypes::Name, required: false
           ),
           Scimitar::Schema::Attribute.new(
-            name: 'vdtpTestByEmail', complexType: Scimitar::ComplexTypes::Email, required: false
+            name: 'complexNames', complexType: Scimitar::ComplexTypes::Name, multiValued:true, required: false
           )
         ]
       end
@@ -72,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