powerhome-scimitar 1.0.0

data/spec/requests/application_controller_spec.rb

@@ -0,0 +1,61 @@
+# Some tests require the more flexible driver methods for 'get', 'post'
+# etc. than available in RSpec controller tests.
+#
+# See also spec/controllers/scimitar/application_controller_spec.rb.
+#
+require 'spec_helper'
+
+RSpec.describe Scimitar::ApplicationController do
+  before :each do
+    allow_any_instance_of(Scimitar::ApplicationController).to receive(:authenticated?).and_return(true)
+  end
+
+  context 'format handling' 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(: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') # Filled in by ApplicationController#require_scim
+    end
+
+    it 'renders 400 if given bad JSON' do
+      post '/CustomRequestVerifiers', params: 'not-json-12345', headers: { 'CONTENT_TYPE' => 'application/scim+json' }
+
+      expect(response).to have_http_status(:bad_request)
+      expect(JSON.parse(response.body)['detail']).to start_with('Invalid JSON - ')
+    end
+
+    it 'translates Content-Type to Rails request format' do
+      get '/CustomRequestVerifiers', headers: { 'CONTENT_TYPE' => 'application/scim+json' }
+
+      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 'translates Content-Type with charset to Rails request format' do
+      get '/CustomRequestVerifiers', headers: { 'CONTENT_TYPE' => 'application/scim+json; charset=utf-8' }
+
+      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; charset=utf-8')
+    end
+
+    it 'translates Rails request format to header' do
+      get '/CustomRequestVerifiers', params: { format: :scim }
+
+      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
+  end
+end

data/spec/requests/controller_configuration_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe 'Controller configuration' do
+  before :each do
+    allow_any_instance_of(Scimitar::ApplicationController).to receive(:authenticated?).and_return(true)
+  end
+
+  context 'application_controller_mixin' do
+    it 'the test before-action declared in configuration gets called' do
+      expect_any_instance_of(MockUsersController).to receive(:test_hook)
+
+      get '/Users', params: { format: :scim }
+
+      expect(response).to be_ok
+    end
+  end # "context 'application_controller_mixin' do"
+end

data/spec/requests/engine_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+RSpec.describe Scimitar::Engine do
+  before :each do
+    allow_any_instance_of(Scimitar::ApplicationController).to receive(:authenticated?).and_return(true)
+  end
+
+  context 'parameter parser' do
+
+    # "params" given here as a String, expecting the engine's custom parser to
+    # decode it for us.
+    #
+    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

@@ -0,0 +1,101 @@
+# ============================================================================
+# PREAMBLE
+# ============================================================================
+
+# Get code coverage reports:
+#
+# https://github.com/colszowka/simplecov#getting-started
+#
+# "Load and launch SimpleCov at the very top of your test/test_helper.rb (or
+#  spec_helper.rb [...])"
+#
+require 'simplecov'
+SimpleCov.start 'rails'
+
+# Rails stuff is related to the self-test applications in 'spec/apps'.
+#
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../apps/dummy/config/environment', __FILE__)
+abort("The Rails environment is running in production mode!") if Rails.env.production?
+
+require 'rspec/rails'
+require 'byebug'
+require 'scimitar'
+
+# ============================================================================
+# MAIN RSPEC CONFIGURATION
+# ============================================================================
+
+RSpec.configure do | config |
+  config.disable_monkey_patching!
+  config.infer_spec_type_from_file_location!
+  config.filter_rails_from_backtrace!
+  config.raise_errors_for_deprecations!
+
+  config.color                      = true
+  config.tty                        = true
+  config.order                      = :random
+  config.fixture_paths              = ["#{::Rails.root}/spec/fixtures"]
+  config.use_transactional_fixtures = true
+
+  Kernel.srand config.seed
+
+  config.around :each do | example |
+    original_engine_configuration = Scimitar.instance_variable_get('@engine_configuration')
+    example.run()
+  ensure
+    Scimitar.instance_variable_set('@engine_configuration', original_engine_configuration)
+  end
+end
+
+# ============================================================================
+# MISCELLANEOUS UTILITIES
+# ============================================================================
+
+# Capture stdout from running a given block.
+#
+def spec_helper_capture_stdout( &block )
+  result = ''
+
+  begin
+    old_stdout = $stdout
+    $stdout = StringIO.new
+
+    yield
+
+    result = $stdout.string
+
+  ensure
+    $stdout = old_stdout
+
+  end
+
+  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,169 @@
+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"
+
+    context 'access and merging' do
+      before :each do
+        @original_subject = subject().to_h().dup()
+      end
+
+      it 'returns keys as Strings' do
+        subject()[:foo] = 1
+        subject()[:BAR] = 2
+
+        expect(subject().keys).to match_array(@original_subject.keys + ['foo', 'BAR'])
+      end
+
+      it 'retains original case of keys' do
+        subject()[:foo ] = 1
+        subject()['FoO'] = 40 # (first-time-set case preservation test in passing)
+        subject()[:BAR ] = 2
+        subject()['Baz'] = 3
+
+        expectation = @original_subject.merge({
+          'foo' => 40,
+          'BAR' => 2,
+          'Baz' => 3
+        })
+
+        expect(subject()).to eql(expectation)
+      end
+
+      it '#merge does not mutate the receiver and retains case of first-set keys' do
+        subject()[:foo] = 1
+        subject()[:BAR] = 2
+
+        pre_merge_subject = subject().dup()
+
+        result      = subject().merge({:FOO => { 'onE' => 40 }, :Baz => 3})
+        expectation = @original_subject.merge({
+          'foo' => { 'onE' => 40 },
+          'BAR' => 2,
+          'Baz' => 3
+        })
+
+        expect(subject()).to eql(pre_merge_subject)
+        expect(result).to eql(expectation)
+      end
+
+      it '#merge! mutates the receiver retains case of first-set keys' do
+        subject()[:foo] = 1
+        subject()[:BAR] = 2
+
+        subject().merge!({:FOO => { 'onE' => 40 }, :Baz => 3})
+
+        expectation = @original_subject.merge({
+          'foo' => { 'onE' => 40 },
+          'BAR' => 2,
+          'Baz' => 3
+        })
+
+        expect(subject()).to eql(expectation)
+      end
+
+      it '#deep_merge does not mutate the receiver and retains nested key cases' do
+        subject()[:foo] = { :one => 10 }
+        subject()[:BAR] = 2
+
+        pre_merge_subject = subject().dup()
+
+        result      = subject().deep_merge({:FOO => { 'ONE' => 40, :TWO => 20 }, :Baz => 3})
+        expectation = @original_subject.merge({
+          'foo' => { 'one' => 40, 'TWO' => 20 },
+          'BAR' => 2,
+          'Baz' => 3
+        })
+
+        expect(subject()).to eql(pre_merge_subject)
+        expect(result).to eql(expectation)
+      end
+
+      it '#deep_merge! mutates the receiver and retains nested key cases' do
+        subject()[:foo] = { :one => 10 }
+        subject()[:BAR] = 2
+
+        subject().deep_merge!({:FOO => { 'ONE' => 40, :TWO => 20 }, :Baz => 3})
+
+        expectation = @original_subject.merge({
+          'foo' => { 'one' => 40, 'TWO' => 20 },
+          'BAR' => 2,
+          'Baz' => 3
+        })
+
+        expect(subject()).to eql(expectation)
+      end
+
+      it 'retains indifferent behaviour after duplication' do
+        subject()[:foo] = { 'onE' => 40 }
+        subject()[:BAR] = 2
+
+        duplicate = subject().dup()
+        duplicate.merge!({ 'FOO' => true, 'baz' => 3 })
+
+        expectation = @original_subject.merge({
+          'foo' => true,
+          'BAR' => 2,
+          'baz' => 3
+        })
+
+        expect(duplicate.to_h).to eql(expectation.to_h)
+      end
+    end # "context 'access and merging' 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