scimaenaga 0.7.0 → 0.9.1

data/spec/lib/scimaenaga/encoder_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Scimaenaga::Encoder do
+  let(:company) { Company.new(subdomain: 'test') }
+
+  describe '::encode' do
+    context 'with signing configuration' do
+      it 'generates a signed token with the company attribute' do
+        token   = Scimaenaga::Encoder.encode(company)
+        payload = Scimaenaga::Encoder.decode(token)
+
+        expect(token).to match(/[a-z|A-Z0-9.]{16,}\.[a-z|A-Z0-9.]{16,}/)
+        expect(payload).to contain_exactly(['iat', Integer], %w[subdomain test])
+      end
+    end
+
+    context 'without signing configuration' do
+      before do
+        allow(Scimaenaga.config).to receive(:signing_secret).and_return(nil)
+        allow(Scimaenaga.config).to receive(:signing_algorithm).and_return(Scimaenaga::Config::ALGO_NONE)
+      end
+
+      it 'generates an unsigned token with the company attribute' do
+        token   = Scimaenaga::Encoder.encode(company)
+        payload = Scimaenaga::Encoder.decode(token)
+
+        expect(token).to match(/[a-z|A-Z0-9.]{16,}/)
+        expect(payload).to contain_exactly(['iat', Integer], %w[subdomain test])
+      end
+    end
+  end
+
+  describe '::decode' do
+    let(:token) { Scimaenaga::Encoder.encode(company) }
+
+    it 'raises InvalidCredentials error for an invalid token' do
+      token = 'f487bf84bfub4f74fj4894fnh483f4h4u8f'
+      expect do
+        Scimaenaga::Encoder.decode(token)
+      end.to raise_error Scimaenaga::ExceptionHandler::InvalidCredentials
+    end
+
+    context 'with signing configuration' do
+      it 'decodes a signed token, returning the company attributes' do
+        payload = Scimaenaga::Encoder.decode(token)
+
+        expect(payload).to contain_exactly(['iat', Integer], %w[subdomain test])
+      end
+    end
+
+    context 'without signing configuration' do
+      before do
+        allow(Scimaenaga.config).to receive(:signing_secret).and_return(nil)
+        allow(Scimaenaga.config).to receive(:signing_algorithm).and_return(Scimaenaga::Config::ALGO_NONE)
+      end
+
+      it 'decodes an unsigned token, returning the company attributes' do
+        payload = Scimaenaga::Encoder.decode(token)
+
+        expect(payload).to contain_exactly(['iat', Integer], %w[subdomain test])
+      end
+    end
+  end
+end

data/spec/libraries/scim_patch_operation_group_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ScimPatchOperationGroup do
+  let(:op) { 'replace' }
+  let(:path) { 'displayName' }
+  let(:value) { 'groupA' }
+  let(:mutable_attributes_schema) { { displayName: :name } }
+  let(:group_member_relation_attribute) { :user_ids }
+
+  let(:user1) { create(:user) }
+  let(:user2) { create(:user) }
+  let(:user3) { create(:user) }
+  let(:user4) { create(:user) }
+  let(:group) { create(:group, users: [user1, user2]) }
+
+  let(:operation) do
+    described_class.new(
+      op,
+      path,
+      value
+    )
+  end
+  context 'replace displayName' do
+    it {
+      allow(Scimaenaga.config).to(
+        receive(:mutable_group_attributes_schema).and_return(mutable_attributes_schema)
+      )
+      allow(Scimaenaga.config).to(
+        receive(:group_member_relation_attribute).and_return(group_member_relation_attribute)
+      )
+      expect(operation.op).to eq 'replace'
+      expect(operation.path_scim).to eq(attribute: path, rest_path: [])
+      expect(operation.path_sp).to eq :name
+      expect(operation.value).to eq value
+
+      operation.save(group)
+      expect(group.name).to eq value
+    }
+  end
+
+  context 'add displayName' do
+    let(:op) { 'add' }
+    it {
+      allow(Scimaenaga.config).to(
+        receive(:mutable_group_attributes_schema).and_return(mutable_attributes_schema)
+      )
+      allow(Scimaenaga.config).to(
+        receive(:group_member_relation_attribute).and_return(group_member_relation_attribute)
+      )
+      expect(operation.op).to eq 'add'
+      expect(operation.path_scim).to eq(attribute: path, rest_path: [])
+      expect(operation.path_sp).to eq :name
+      expect(operation.value).to eq value
+
+      operation.save(group)
+      expect(group.name).to eq value
+    }
+  end
+
+  context 'remove displayName' do
+    let(:op) { 'remove' }
+    it {
+      allow(Scimaenaga.config).to(
+        receive(:mutable_group_attributes_schema).and_return(mutable_attributes_schema)
+      )
+      allow(Scimaenaga.config).to(
+        receive(:group_member_relation_attribute).and_return(group_member_relation_attribute)
+      )
+      expect(operation.op).to eq 'remove'
+      expect(operation.path_scim).to eq(attribute: path, rest_path: [])
+      expect(operation.path_sp).to eq :name
+      expect(operation.value).to eq value
+
+      operation.save(group)
+      expect(group.name).to eq nil
+    }
+  end
+
+  context 'add member' do
+    let(:op) { 'add' }
+    let(:path) { 'members' }
+    let(:value) { [{ 'value' => user3.id.to_s }, { 'value' => user4.id.to_s }] }
+    it {
+      allow(Scimaenaga.config).to(
+        receive(:mutable_group_attributes_schema).and_return(mutable_attributes_schema)
+      )
+      allow(Scimaenaga.config).to(
+        receive(:group_member_relation_attribute).and_return(group_member_relation_attribute)
+      )
+      expect(operation.op).to eq 'add'
+      expect(operation.path_scim).to eq(attribute: 'members', rest_path: [])
+      expect(operation.path_sp).to eq :user_ids
+      expect(operation.value).to eq value
+
+      operation.save(group)
+      expect(group.users).to eq [user1, user2, user3, user4]
+    }
+  end
+
+  context 'replace member' do
+    let(:op) { 'replace' }
+    let(:path) { 'members' }
+    let(:value) { [{ 'value' => user3.id.to_s }, { 'value' => user4.id.to_s }] }
+    it {
+      allow(Scimaenaga.config).to(
+        receive(:mutable_group_attributes_schema).and_return(mutable_attributes_schema)
+      )
+      allow(Scimaenaga.config).to(
+        receive(:group_member_relation_attribute).and_return(group_member_relation_attribute)
+      )
+      expect(operation.op).to eq 'replace'
+      expect(operation.path_scim).to eq(attribute: 'members', rest_path: [])
+      expect(operation.path_sp).to eq :user_ids
+      expect(operation.value).to eq value
+
+      operation.save(group)
+      expect(group.users).to eq [user3, user4]
+    }
+  end
+
+  context 'remove user ids' do
+    let(:op) { 'remove' }
+    let(:path) { 'members' }
+    let(:value) { [{ 'value' => user1.id.to_s }, { 'value' => user2.id.to_s }] }
+    it {
+      allow(Scimaenaga.config).to(
+        receive(:mutable_group_attributes_schema).and_return(mutable_attributes_schema)
+      )
+      allow(Scimaenaga.config).to(
+        receive(:group_member_relation_attribute).and_return(group_member_relation_attribute)
+      )
+      expect(operation.op).to eq 'remove'
+      expect(operation.path_scim).to eq(attribute: 'members', rest_path: [])
+      expect(operation.path_sp).to eq :user_ids
+      expect(operation.value).to eq value
+
+      operation.save(group)
+      expect(group.users).to eq []
+    }
+  end
+
+  context 'remove user id (with filter)' do
+    let(:op) { 'remove' }
+    let(:path) { "members[value eq \"#{user1.id}\"]" }
+    let(:value) { nil }
+    it {
+      allow(Scimaenaga.config).to(
+        receive(:mutable_group_attributes_schema).and_return(mutable_attributes_schema)
+      )
+      allow(Scimaenaga.config).to(
+        receive(:group_member_relation_attribute).and_return(group_member_relation_attribute)
+      )
+      expect(operation.op).to eq 'remove'
+      expect(operation.path_scim).to eq(attribute: 'members',
+                                        filter: { attribute: 'value', operator: 'eq', parameter: user1.id.to_s }, rest_path: [])
+      expect(operation.path_sp).to eq :user_ids
+      expect(operation.value).to eq nil
+
+      operation.save(group)
+      expect(group.users).to eq [user2]
+    }
+  end
+end

data/spec/libraries/scim_patch_operation_user_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ScimPatchOperationUser do
+  let(:op) { 'replace' }
+  let(:path) { 'userName' }
+  let(:value) { 'taro.suzuki' }
+  let(:mutable_attributes_schema) do
+    {
+      userName: :name,
+      displayName: :display_name,
+      emails: [
+        {
+          value: :email,
+        }
+      ],
+      name: {
+        familyName: :family_name,
+        givenName: :given_name,
+      },
+      active: :active,
+    }
+  end
+
+  let(:operation) do
+    described_class.new(
+      op,
+      path,
+      value
+    )
+  end
+  describe '#initialize' do
+    context 'replace single attribute' do
+      it {
+        allow(Scimaenaga.config).to(
+          receive(:mutable_user_attributes_schema).and_return(mutable_attributes_schema)
+        )
+        expect(operation.op).to eq 'replace'
+        expect(operation.path_scim).to eq(attribute: path, rest_path: [])
+        expect(operation.path_sp).to eq :name
+        expect(operation.value).to eq value
+      }
+    end
+
+    context 'add single attribute' do
+      let(:op) { 'add' }
+      it {
+        allow(Scimaenaga.config).to(
+          receive(:mutable_user_attributes_schema).and_return(mutable_attributes_schema)
+        )
+        expect(operation.op).to eq 'add'
+        expect(operation.path_scim).to eq(attribute: path, rest_path: [])
+        expect(operation.path_sp).to eq :name
+        expect(operation.value).to eq value
+      }
+    end
+
+    context 'remove single attribute' do
+      let(:op) { 'remove' }
+      it {
+        allow(Scimaenaga.config).to(
+          receive(:mutable_user_attributes_schema).and_return(mutable_attributes_schema)
+        )
+        expect(operation.op).to eq 'remove'
+        expect(operation.path_scim).to eq(attribute: path, rest_path: [])
+        expect(operation.path_sp).to eq :name
+        expect(operation.value).to eq value
+      }
+    end
+
+    context 'replace email address' do
+      let(:path) { 'emails[type eq "work"].value' }
+      let(:value) { 'taro.suzuki@example.com' }
+      it {
+        allow(Scimaenaga.config).to(
+          receive(:mutable_user_attributes_schema).and_return(mutable_attributes_schema)
+        )
+        expect(operation.op).to eq 'replace'
+        expect(operation.path_scim).to eq(attribute: 'emails',
+                                          filter: { attribute: 'type', operator: 'eq', parameter: 'work' }, rest_path: ['value'])
+        expect(operation.path_sp).to eq :email
+        expect(operation.value).to eq value
+      }
+    end
+
+    context 'replace name.familyName' do
+      let(:path) { 'name.familyName' }
+      let(:value) { 'Suzuki' }
+      it {
+        allow(Scimaenaga.config).to(
+          receive(:mutable_user_attributes_schema).and_return(mutable_attributes_schema)
+        )
+        expect(operation.op).to eq 'replace'
+        expect(operation.path_scim).to eq(attribute: 'name', rest_path: ['familyName'])
+        expect(operation.path_sp).to eq :family_name
+        expect(operation.value).to eq value
+      }
+    end
+  end
+end

data/spec/libraries/scim_patch_spec.rb

@@ -3,35 +3,39 @@
 require 'spec_helper'
 
 describe ScimPatch do
-  let(:params) do
-    {
-      'schemas' => ['urn:ietf:params:scim:api:messages:2.0:PatchOp'],
-      'Operations' => [
-        {
-          'op' => 'Replace',
-          'path' => 'userName',
-          'value' => 'taro.suzuki',
-        },
-        {
-          'op' => 'Replace',
-          'path' => 'emails[type eq "work"].value',
-          'value' => 'taro.suzuki@example.com',
-        },
-        {
-          'op' => 'Replace',
-          'path' => 'name.familyName',
-          'value' => 'Suzuki',
-        },
-        {
-          'op' => 'Replace',
-          'path' => 'active',
-          'value' => 'False',
-        }
-      ],
+  shared_examples :user do
+    let(:patch) { ScimPatch.new(params, :user) }
+    it {
+      allow(Scimaenaga.config).to(
+        receive(:mutable_user_attributes_schema).and_return(mutable_user_attributes_schema)
+      )
+
+      expect(patch.operations[0].op).to eq 'replace'
+      expect(patch.operations[0].path_scim).to eq(attribute: 'emails',
+                                                  filter: { attribute: 'type', operator: 'eq', parameter: 'work' }, rest_path: ['value'])
+      expect(patch.operations[0].path_sp).to eq :email
+      expect(patch.operations[0].value).to eq 'taro.suzuki@example.com'
+
+      expect(patch.operations[1].op).to eq 'replace'
+      expect(patch.operations[1].path_scim).to eq(attribute: 'userName', rest_path: [])
+      expect(patch.operations[1].path_sp).to eq :name
+      expect(patch.operations[1].value).to eq 'taro.suzuki'
+
+      expect(patch.operations[2].op).to eq 'replace'
+      expect(patch.operations[2].path_scim).to eq(attribute: 'name',
+                                                  rest_path: ['familyName'])
+      expect(patch.operations[2].path_sp).to eq :family_name
+      expect(patch.operations[2].value).to eq 'Suzuki'
+
+      expect(patch.operations[3].op).to eq 'replace'
+      expect(patch.operations[3].path_scim).to eq(attribute: 'active',
+                                                  rest_path: [])
+      expect(patch.operations[3].path_sp).to eq :active
+      expect(patch.operations[3].value).to eq false
     }
   end
 
-  let(:mutable_attributes_schema) do
+  let(:mutable_user_attributes_schema) do
     {
       userName: :name,
       displayName: :display_name,
@@ -48,29 +52,109 @@ describe ScimPatch do
     }
   end
 
-  let(:patch) { described_class.new(params, mutable_attributes_schema) }
+  let(:mutable_group_attributes_schema) do
+    {
+      displayName: :name,
+    }
+  end
 
-  describe '#initialize' do
-    it {
-      expect(patch.operations[0].operations[0].op).to eq :replace
-      expect(patch.operations[0].operations[0].path_scim).to eq 'userName'
-      expect(patch.operations[0].operations[0].path_sp).to eq :name
-      expect(patch.operations[0].operations[0].value).to eq 'taro.suzuki'
+  describe '#initialize :user' do
+    context :multiple_single_value_operations do
+      let(:params) do
+        {
+          'schemas' => ['urn:ietf:params:scim:api:messages:2.0:PatchOp'],
+          'Operations' => [
+            {
+              'op' => 'Replace',
+              'path' => 'emails[type eq "work"].value',
+              'value' => 'taro.suzuki@example.com',
+            },
+            {
+              'op' => 'Replace',
+              'path' => 'userName',
+              'value' => 'taro.suzuki',
+            },
+            {
+              'op' => 'Replace',
+              'path' => 'name.familyName',
+              'value' => 'Suzuki',
+            },
+            {
+              'op' => 'Replace',
+              'path' => 'active',
+              'value' => 'False',
+            }
+          ],
+        }
+      end
+      it_behaves_like :user
+    end
 
-      expect(patch.operations[1].operations[0].op).to eq :replace
-      expect(patch.operations[1].operations[0].path_scim).to eq 'emails[type eq "work"].value'
-      expect(patch.operations[1].operations[0].path_sp).to eq :email
-      expect(patch.operations[1].operations[0].value).to eq 'taro.suzuki@example.com'
+    context :multiple_value_operation do
+      let(:params) do
+        {
+          'schemas' => ['urn:ietf:params:scim:api:messages:2.0:PatchOp'],
+          'Operations' => [
+            {
+              'op' => 'replace',
+              'path' => 'emails[type eq "work"].value',
+              'value' => 'taro.suzuki@example.com',
+            },
+            {
+              'op' => 'replace',
+              'value' => {
+                'userName' => 'taro.suzuki',
+                'name.familyName' => 'Suzuki',
+                'active' => false,
+              },
+            }
+          ],
+        }
+      end
+      it_behaves_like :user
+    end
+  end
+
+  describe '#initialize :group' do
+    let(:params) do
+      {
+        'schemas' => ['urn:ietf:params:scim:api:messages:2.0:PatchOp'],
+        'Operations' => [
+          {
+            'op' => 'Replace',
+            'path' => 'displayName',
+            'value' => 'groupA',
+          },
+          {
+            'op' => 'Add',
+            'path' => 'members',
+            'value' => [
+              {
+                'value' => '1',
+              },
+              {
+                'value' => '2',
+              }
+            ],
+          }
+        ],
+      }
+    end
+    let(:patch) { described_class.new(params, :group) }
+    it {
+      allow(Scimaenaga.config).to(
+        receive(:mutable_group_attributes_schema).and_return(mutable_group_attributes_schema)
+      )
 
-      expect(patch.operations[2].operations[0].op).to eq :replace
-      expect(patch.operations[2].operations[0].path_scim).to eq 'name.familyName'
-      expect(patch.operations[2].operations[0].path_sp).to eq :family_name
-      expect(patch.operations[2].operations[0].value).to eq 'Suzuki'
+      expect(patch.operations[0].op).to eq 'replace'
+      expect(patch.operations[0].path_scim).to eq(attribute: 'displayName', rest_path: [])
+      expect(patch.operations[0].path_sp).to eq :name
+      expect(patch.operations[0].value).to eq 'groupA'
 
-      expect(patch.operations[3].operations[0].op).to eq :replace
-      expect(patch.operations[3].operations[0].path_scim).to eq 'active'
-      expect(patch.operations[3].operations[0].path_sp).to eq :active
-      expect(patch.operations[3].operations[0].value).to eq false
+      expect(patch.operations[1].op).to eq 'add'
+      expect(patch.operations[1].path_scim).to eq(attribute: 'members', rest_path: [])
+      expect(patch.operations[1].path_sp).to eq :user_ids
+      expect(patch.operations[1].value).to eq [{ 'value' => '1' }, { 'value' => '2' }]
     }
   end
 

data/spec/models/scim_query_parser_spec.rb

@@ -2,19 +2,18 @@
 
 require 'spec_helper'
 
-describe ScimRails::ScimQueryParser do
-
+describe Scimaenaga::ScimQueryParser do
   let(:query_string) { 'userName eq "taro"' }
-  let(:queryable_attributes) {
+  let(:queryable_attributes) do
     {
       userName: :name,
       emails: [
         {
-          value: :email
+          value: :email,
         }
-      ]
+      ],
     }
-  }
+  end
   let(:parser) { described_class.new(query_string, queryable_attributes) }
 
   describe '#attribute' do