scimitar 1.7.1 → 2.0.0

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

@@ -405,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
 
@@ -425,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
@@ -435,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
@@ -481,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
@@ -559,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"
 
@@ -580,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"
 
@@ -592,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
@@ -613,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"
 
@@ -657,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

@@ -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