scimitar 1.0.3 → 1.2.1

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

@@ -15,6 +15,19 @@ RSpec.describe Scimitar::Resources::User do
       expect(user.as_json['name']['errors']).to be_nil
     end
 
+    it 'treats attributes as case-insensitive' do
+      user = described_class.new(name: Scimitar::ComplexTypes::Name.new(
+        FAMILYNAME: 'Smith',
+        GIVENNAME: 'John',
+        FORMATTED: 'John Smith'
+      ))
+
+      expect(user.name.familyName).to eql('Smith')
+      expect(user.name.givenName).to eql('John')
+      expect(user.name.formatted).to eql('John Smith')
+      expect(user.as_json['name']['errors']).to be_nil
+    end
+
     it 'validates that the provided name matches the name schema' do
       user = described_class.new(name: Scimitar::ComplexTypes::Email.new(
         value: 'john@smoth.com',

data/spec/requests/active_record_backed_resources_controller_spec.rb

@@ -146,41 +146,41 @@ RSpec.describe Scimitar::ActiveRecordBackedResourcesController do
 
   context '#create' do
     context 'creates an item' do
-      it 'with minimal parameters' do
-        mock_before = MockUser.all.to_a
+      shared_examples 'a creator' do | force_upper_case: |
+        it 'with minimal parameters' do
+          mock_before = MockUser.all.to_a
 
-        expect_any_instance_of(MockUsersController).to receive(:create).once.and_call_original
-        expect {
-          post "/Users", params: {
-            format: :scim,
-            userName: '4' # Minimum required by schema
-          }
-        }.to change { MockUser.count }.by(1)
+          attributes = { userName: '4' }  # Minimum required by schema
+          attributes = spec_helper_hupcase(attributes) if force_upper_case
 
-        mock_after = MockUser.all.to_a
-        new_mock = (mock_after - mock_before).first
+          expect_any_instance_of(MockUsersController).to receive(:create).once.and_call_original
+          expect {
+            post "/Users", params: attributes.merge(format: :scim)
+          }.to change { MockUser.count }.by(1)
 
-        expect(response.status).to eql(201)
-        result = JSON.parse(response.body)
+          mock_after = MockUser.all.to_a
+          new_mock = (mock_after - mock_before).first
 
-        expect(result['id']).to eql(new_mock.id.to_s)
-        expect(result['meta']['resourceType']).to eql('User')
-        expect(new_mock.username).to eql('4')
-      end
+          expect(response.status).to eql(201)
+          result = JSON.parse(response.body)
 
-      # A bit of extra coverage just for general confidence.
-      #
-      it 'with more comprehensive parameters' do
-        mock_before = MockUser.all.to_a
+          expect(result['id']).to eql(new_mock.id.to_s)
+          expect(result['meta']['resourceType']).to eql('User')
+          expect(new_mock.username).to eql('4')
+        end
 
-        expect {
-          post "/Users", params: {
-            format: :scim,
+        # A bit of extra coverage just for general confidence.
+        #
+        it 'with more comprehensive parameters' do
+          mock_before = MockUser.all.to_a
+
+          attributes = {
             userName: '4',
             name: {
               givenName: 'Given',
               familyName: 'Family'
             },
+            meta: { resourceType: 'User' },
             emails: [
               {
                 type: 'work',
@@ -192,22 +192,36 @@ RSpec.describe Scimitar::ActiveRecordBackedResourcesController do
               }
             ]
           }
-        }.to change { MockUser.count }.by(1)
 
-        mock_after = MockUser.all.to_a
-        new_mock = (mock_after - mock_before).first
+          attributes = spec_helper_hupcase(attributes) if force_upper_case
 
-        expect(response.status).to eql(201)
-        result = JSON.parse(response.body)
+          expect {
+            post "/Users", params: attributes.merge(format: :scim)
+          }.to change { MockUser.count }.by(1)
 
-        expect(result['id']).to eql(new_mock.id.to_s)
-        expect(result['meta']['resourceType']).to eql('User')
-        expect(new_mock.username).to eql('4')
-        expect(new_mock.first_name).to eql('Given')
-        expect(new_mock.last_name).to eql('Family')
-        expect(new_mock.home_email_address).to eql('home_4@test.com')
-        expect(new_mock.work_email_address).to eql('work_4@test.com')
-      end
+          mock_after = MockUser.all.to_a
+          new_mock = (mock_after - mock_before).first
+
+          expect(response.status).to eql(201)
+          result = JSON.parse(response.body)
+
+          expect(result['id']).to eql(new_mock.id.to_s)
+          expect(result['meta']['resourceType']).to eql('User')
+          expect(new_mock.username).to eql('4')
+          expect(new_mock.first_name).to eql('Given')
+          expect(new_mock.last_name).to eql('Family')
+          expect(new_mock.home_email_address).to eql('home_4@test.com')
+          expect(new_mock.work_email_address).to eql('work_4@test.com')
+        end
+      end # "shared_examples 'a creator' do | force_upper_case: |"
+
+      context 'using schema-matched case' do
+        it_behaves_like 'a creator', force_upper_case: false
+      end # "context 'using schema-matched case' do"
+
+      context 'using upper case' do
+        it_behaves_like 'a creator', force_upper_case: true
+      end # "context 'using upper case' do"
     end
 
     it 'returns 409 for duplicates (by Rails validation)' do
@@ -258,28 +272,38 @@ RSpec.describe Scimitar::ActiveRecordBackedResourcesController do
   # ===========================================================================
 
   context '#replace' do
-    it 'replaces all attributes in an instance' do
-      expect_any_instance_of(MockUsersController).to receive(:replace).once.and_call_original
-      expect {
-        put "/Users/#{@u2.id}", params: {
-          format: :scim,
-          userName: '4' # Minimum required by schema
-        }
-      }.to_not change { MockUser.count }
+    shared_examples 'a replacer' do | force_upper_case: |
+      it 'which replaces all attributes in an instance' do
+        attributes = { userName: '4' }  # Minimum required by schema
+        attributes = spec_helper_hupcase(attributes) if force_upper_case
 
-      expect(response.status).to eql(200)
-      result = JSON.parse(response.body)
+        expect_any_instance_of(MockUsersController).to receive(:replace).once.and_call_original
+        expect {
+          put "/Users/#{@u2.id}", params: attributes.merge(format: :scim)
+        }.to_not change { MockUser.count }
 
-      expect(result['id']).to eql(@u2.id.to_s)
-      expect(result['meta']['resourceType']).to eql('User')
+        expect(response.status).to eql(200)
+        result = JSON.parse(response.body)
 
-      @u2.reload
+        expect(result['id']).to eql(@u2.id.to_s)
+        expect(result['meta']['resourceType']).to eql('User')
 
-      expect(@u2.username).to eql('4')
-      expect(@u2.first_name).to be_nil
-      expect(@u2.last_name).to be_nil
-      expect(@u2.home_email_address).to be_nil
-    end
+        @u2.reload
+
+        expect(@u2.username).to eql('4')
+        expect(@u2.first_name).to be_nil
+        expect(@u2.last_name).to be_nil
+        expect(@u2.home_email_address).to be_nil
+      end
+    end # "shared_examples 'a replacer' do | force_upper_case: |"
+
+    context 'using schema-matched case' do
+      it_behaves_like 'a replacer', force_upper_case: false
+    end # "context 'using schema-matched case' do"
+
+    context 'using upper case' do
+      it_behaves_like 'a replacer', force_upper_case: true
+    end # "context 'using upper case' do"
 
     it 'notes schema validation failures' do
       expect {
@@ -341,11 +365,9 @@ RSpec.describe Scimitar::ActiveRecordBackedResourcesController do
   # ===========================================================================
 
   context '#update' do
-    it 'patches specific attributes' do
-      expect_any_instance_of(MockUsersController).to receive(:update).once.and_call_original
-      expect {
-        patch "/Users/#{@u2.id}", params: {
-          format: :scim,
+    shared_examples 'an updater' do | force_upper_case: |
+      it 'which patches specific attributes' do
+        payload = {
           Operations: [
             {
               op: 'add',
@@ -359,33 +381,36 @@ RSpec.describe Scimitar::ActiveRecordBackedResourcesController do
             }
           ]
         }
-      }.to_not change { MockUser.count }
 
-      expect(response.status).to eql(200)
-      result = JSON.parse(response.body)
+        payload = spec_helper_hupcase(payload) if force_upper_case
 
-      expect(result['id']).to eql(@u2.id.to_s)
-      expect(result['meta']['resourceType']).to eql('User')
+        expect_any_instance_of(MockUsersController).to receive(:update).once.and_call_original
+        expect {
+          patch "/Users/#{@u2.id}", params: payload.merge(format: :scim)
+        }.to_not change { MockUser.count }
 
-      @u2.reload
+        expect(response.status).to eql(200)
+        result = JSON.parse(response.body)
 
-      expect(@u2.username).to eql('4')
-      expect(@u2.first_name).to eql('Foo')
-      expect(@u2.last_name).to eql('Bar')
-      expect(@u2.home_email_address).to eql('home_2@test.com')
-      expect(@u2.work_email_address).to eql('work_4@test.com')
-    end
+        expect(result['id']).to eql(@u2.id.to_s)
+        expect(result['meta']['resourceType']).to eql('User')
 
-    context 'clears attributes' do
-      before :each do
-        @u2.update!(work_email_address: 'work_2@test.com')
+        @u2.reload
+
+        expect(@u2.username).to eql('4')
+        expect(@u2.first_name).to eql('Foo')
+        expect(@u2.last_name).to eql('Bar')
+        expect(@u2.home_email_address).to eql('home_2@test.com')
+        expect(@u2.work_email_address).to eql('work_4@test.com')
       end
 
-      it 'with simple paths' do
-        expect_any_instance_of(MockUsersController).to receive(:update).once.and_call_original
-        expect {
-          patch "/Users/#{@u2.id}", params: {
-            format: :scim,
+      context 'which clears attributes' do
+        before :each do
+          @u2.update!(work_email_address: 'work_2@test.com')
+        end
+
+        it 'with simple paths' do
+          payload = {
             Operations: [
               {
                 op: 'remove',
@@ -393,28 +418,31 @@ RSpec.describe Scimitar::ActiveRecordBackedResourcesController do
               }
             ]
           }
-        }.to_not change { MockUser.count }
 
-        expect(response.status).to eql(200)
-        result = JSON.parse(response.body)
+          payload = spec_helper_hupcase(payload) if force_upper_case
 
-        expect(result['id']).to eql(@u2.id.to_s)
-        expect(result['meta']['resourceType']).to eql('User')
+          expect_any_instance_of(MockUsersController).to receive(:update).once.and_call_original
+          expect {
+            patch "/Users/#{@u2.id}", params: payload.merge(format: :scim)
+          }.to_not change { MockUser.count }
 
-        @u2.reload
+          expect(response.status).to eql(200)
+          result = JSON.parse(response.body)
 
-        expect(@u2.username).to eql('2')
-        expect(@u2.first_name).to be_nil
-        expect(@u2.last_name).to eql('Bar')
-        expect(@u2.home_email_address).to eql('home_2@test.com')
-        expect(@u2.work_email_address).to eql('work_2@test.com')
-      end
+          expect(result['id']).to eql(@u2.id.to_s)
+          expect(result['meta']['resourceType']).to eql('User')
 
-      it 'by array entry filter match' do
-        expect_any_instance_of(MockUsersController).to receive(:update).once.and_call_original
-        expect {
-          patch "/Users/#{@u2.id}", params: {
-            format: :scim,
+          @u2.reload
+
+          expect(@u2.username).to eql('2')
+          expect(@u2.first_name).to be_nil
+          expect(@u2.last_name).to eql('Bar')
+          expect(@u2.home_email_address).to eql('home_2@test.com')
+          expect(@u2.work_email_address).to eql('work_2@test.com')
+        end
+
+        it 'by array entry filter match' do
+          payload = {
             Operations: [
               {
                 op: 'remove',
@@ -422,28 +450,31 @@ RSpec.describe Scimitar::ActiveRecordBackedResourcesController do
               }
             ]
           }
-        }.to_not change { MockUser.count }
 
-        expect(response.status).to eql(200)
-        result = JSON.parse(response.body)
+          payload = spec_helper_hupcase(payload) if force_upper_case
 
-        expect(result['id']).to eql(@u2.id.to_s)
-        expect(result['meta']['resourceType']).to eql('User')
+          expect_any_instance_of(MockUsersController).to receive(:update).once.and_call_original
+          expect {
+            patch "/Users/#{@u2.id}", params: payload.merge(format: :scim)
+          }.to_not change { MockUser.count }
 
-        @u2.reload
+          expect(response.status).to eql(200)
+          result = JSON.parse(response.body)
 
-        expect(@u2.username).to eql('2')
-        expect(@u2.first_name).to eql('Foo')
-        expect(@u2.last_name).to eql('Bar')
-        expect(@u2.home_email_address).to eql('home_2@test.com')
-        expect(@u2.work_email_address).to be_nil
-      end
+          expect(result['id']).to eql(@u2.id.to_s)
+          expect(result['meta']['resourceType']).to eql('User')
 
-      it 'by whole collection' do
-        expect_any_instance_of(MockUsersController).to receive(:update).once.and_call_original
-        expect {
-          patch "/Users/#{@u2.id}", params: {
-            format: :scim,
+          @u2.reload
+
+          expect(@u2.username).to eql('2')
+          expect(@u2.first_name).to eql('Foo')
+          expect(@u2.last_name).to eql('Bar')
+          expect(@u2.home_email_address).to eql('home_2@test.com')
+          expect(@u2.work_email_address).to be_nil
+        end
+
+        it 'by whole collection' do
+          payload = {
             Operations: [
               {
                 op: 'remove',
@@ -451,23 +482,38 @@ RSpec.describe Scimitar::ActiveRecordBackedResourcesController do
               }
             ]
           }
-        }.to_not change { MockUser.count }
 
-        expect(response.status).to eql(200)
-        result = JSON.parse(response.body)
+          payload = spec_helper_hupcase(payload) if force_upper_case
 
-        expect(result['id']).to eql(@u2.id.to_s)
-        expect(result['meta']['resourceType']).to eql('User')
+          expect_any_instance_of(MockUsersController).to receive(:update).once.and_call_original
+          expect {
+            patch "/Users/#{@u2.id}", params: payload.merge(format: :scim)
+          }.to_not change { MockUser.count }
 
-        @u2.reload
+          expect(response.status).to eql(200)
+          result = JSON.parse(response.body)
 
-        expect(@u2.username).to eql('2')
-        expect(@u2.first_name).to eql('Foo')
-        expect(@u2.last_name).to eql('Bar')
-        expect(@u2.home_email_address).to be_nil
-        expect(@u2.work_email_address).to be_nil
-      end
-    end # "context 'clears attributes' do"
+          expect(result['id']).to eql(@u2.id.to_s)
+          expect(result['meta']['resourceType']).to eql('User')
+
+          @u2.reload
+
+          expect(@u2.username).to eql('2')
+          expect(@u2.first_name).to eql('Foo')
+          expect(@u2.last_name).to eql('Bar')
+          expect(@u2.home_email_address).to be_nil
+          expect(@u2.work_email_address).to be_nil
+        end
+      end # "context 'which clears attributes' do"
+    end # "shared_examples 'an updater' do | force_upper_case: |"
+
+    context 'using schema-matched case' do
+      it_behaves_like 'an updater', force_upper_case: false
+    end # "context 'using schema-matched case' do"
+
+    context 'using upper case' do
+      it_behaves_like 'an updater', force_upper_case: true
+    end # "context 'using upper case' do"
 
     it 'notes Rails validation failures' do
       expect {

data/spec/requests/application_controller_spec.rb

@@ -11,11 +11,14 @@ RSpec.describe Scimitar::ApplicationController do
   end
 
   context 'format handling' do
-    it 'renders "not acceptable" if the request does not use SCIM type' do
+    it 'renders "OK" if the request does not provide any Content-Type value' do
       get '/CustomRequestVerifiers', params: { format: :html }
 
-      expect(response).to have_http_status(:not_acceptable)
-      expect(JSON.parse(response.body)['detail']).to eql('Only application/scim+json type is accepted.')
+      expect(response).to have_http_status(:ok)
+      parsed_body = JSON.parse(response.body)
+      expect(parsed_body['request']['is_scim'     ]).to eql(true)
+      expect(parsed_body['request']['format'      ]).to eql('application/scim+json')
+      expect(parsed_body['request']['content_type']).to eql('application/scim+json')
     end
 
     it 'renders 400 if given bad JSON' do

data/spec/requests/engine_spec.rb

@@ -10,11 +10,36 @@ RSpec.describe Scimitar::Engine do
     # "params" given here as a String, expecting the engine's custom parser to
     # decode it for us.
     #
-    it 'decodes JSON', type: :model do
+    it 'decodes simple JSON', type: :model do
       post '/Users.scim', params: '{"userName": "foo"}', headers: { 'CONTENT_TYPE' => 'application/scim+json' }
 
       expect(response.status).to eql(201)
       expect(JSON.parse(response.body)['userName']).to eql('foo')
     end
+
+    it 'decodes nested JSON', type: :model do
+      post '/Users.scim', params: '{"userName": "foo", "name": {"givenName": "bar", "familyName": "baz"}}', headers: { 'CONTENT_TYPE' => 'application/scim+json' }
+
+      expect(response.status).to eql(201)
+      expect(JSON.parse(response.body)['userName']).to eql('foo')
+      expect(JSON.parse(response.body)['name']['givenName']).to eql('bar')
+      expect(JSON.parse(response.body)['name']['familyName']).to eql('baz')
+    end
+
+    it 'is case insensitive at the top level', type: :model do
+      post '/Users.scim', params: '{"USERNAME": "foo"}', headers: { 'CONTENT_TYPE' => 'application/scim+json' }
+
+      expect(response.status).to eql(201)
+      expect(JSON.parse(response.body)['userName']).to eql('foo')
+    end
+
+    it 'is case insensitive in nested levels', type: :model do
+      post '/Users.scim', params: '{"USERNAME": "foo", "NAME": {"GIVENNAME": "bar", "FAMILYNAME": "baz"}}', headers: { 'CONTENT_TYPE' => 'application/scim+json' }
+
+      expect(response.status).to eql(201)
+      expect(JSON.parse(response.body)['userName']).to eql('foo')
+      expect(JSON.parse(response.body)['name']['givenName']).to eql('bar')
+      expect(JSON.parse(response.body)['name']['familyName']).to eql('baz')
+    end
   end # "context 'parameter parser' do"
 end

data/spec/spec_helper.rb

@@ -64,3 +64,30 @@ def spec_helper_capture_stdout( &block )
 
   return result
 end
+
+# Recursively transform the keys of any given Hash or any Hashes in a given
+# Array into uppercase form, retaining Symbol or String keys. Returns the
+# transformed duplicate structure.
+#
+# Only Hashes or Hash entries within an Array are converted. Other data is left
+# alone. The original input item is not modified.
+#
+# IMPORTANT: HashWithIndifferentAccess or similar subclasses are not supported.
+#
+# +item+:: Hash or Array that might contain some Hashes.
+#
+def spec_helper_hupcase(item)
+  if item.is_a?(Hash)
+    rehash = item.transform_keys(&:upcase)
+    rehash.each do | key, value |
+      rehash[key] = spec_helper_hupcase(value)
+    end
+    rehash
+  elsif item.is_a?(Array)
+    item.map do | array_entry |
+      spec_helper_hupcase(array_entry)
+    end
+  else
+    item
+  end
+end

data/spec/spec_helper_spec.rb

@@ -0,0 +1,30 @@
+# Self-test. Sometimes tests call into utility methods in spec_helper.rb;
+# if those aren't doing what they should, then the tests might give false
+# positive passes.
+#
+require 'spec_helper'
+
+RSpec.describe 'spec_helper.rb self-test' do
+  context '#spec_helper_hupcase' do
+    it 'converts a flat Hash, preserving data type of keys' do
+      input  = {:one => 1, 'two' => 2}
+      output = spec_helper_hupcase(input)
+
+      expect(output).to eql({:ONE => 1, 'TWO' => 2})
+    end
+
+    it 'converts a nested Hash' do
+      input  = {:one => 1, 'two' => {:tHrEe => {'fOuR' => 4}}}
+      output = spec_helper_hupcase(input)
+
+      expect(output).to eql({:ONE => 1, 'TWO' => {:THREE => {'FOUR' => 4}}})
+    end
+
+    it 'converts an Array with Hashes' do
+      input  = {:one => 1, 'two' => [true, 42, {:tHrEe => {'fOuR' => 4}}]}
+      output = spec_helper_hupcase(input)
+
+      expect(output).to eql({:ONE => 1, 'TWO' => [true, 42, {:THREE => {'FOUR' => 4}}]})
+    end
+  end # "context '#spec_helper_hupcase' do"
+end

data/spec/support/hash_with_indifferent_case_insensitive_access_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.describe Scimitar::Support::HashWithIndifferentCaseInsensitiveAccess do
+  shared_examples 'an indifferent access, case insensitive Hash' do
+    context 'where keys set as strings' do
+      it 'can be retrieved via any case' do
+        subject()['foo'] = 1
+
+        expect(subject()['FOO']).to eql(1)
+        expect(subject()[:FoO ]).to eql(1)
+        expect(subject()['bar']).to be_nil
+      end
+
+      it 'can be checked for via any case' do
+        subject()['foo'] = 1
+
+        expect(subject()).to     have_key('FOO')
+        expect(subject()).to     have_key(:FoO )
+        expect(subject()).to_not have_key('bar')
+      end
+    end # "context 'where keys set as strings' do"
+
+    context 'where keys set as symbols' do
+      it 'retrieves via any case' do
+        subject()[:foo] = 1
+
+        expect(subject()['FOO']).to eql(1)
+        expect(subject()[:FoO ]).to eql(1)
+        expect(subject()['bar']).to be_nil
+      end
+
+      it 'enquires via any case' do
+        subject()[:foo] = 1
+
+        expect(subject()).to     have_key('FOO')
+        expect(subject()).to     have_key(:FoO )
+        expect(subject()).to_not have_key('bar')
+      end
+    end # "context 'where keys set as symbols' do"
+  end # "shared_examples 'an indifferent access, case insensitive Hash' do"
+
+  context 'when created directly' do
+    subject do
+      described_class.new()
+    end
+
+    it_behaves_like 'an indifferent access, case insensitive Hash'
+  end # "context 'when created directly' do"
+
+  context 'when created through conversion' do
+    subject do
+      { 'test' => 2 }.with_indifferent_access.with_indifferent_case_insensitive_access()
+    end
+
+    it 'includes the original data' do
+      expect(subject()[:TEST]).to eql(2)
+    end
+
+    it_behaves_like 'an indifferent access, case insensitive Hash'
+  end # "context 'converting hashes' do"
+end