scimitar 1.8.2 → 2.0.0

data/spec/apps/dummy/db/migrate/20210308044214_create_join_table_mock_groups_mock_users.rb

@@ -1,13 +1,8 @@
 class CreateJoinTableMockGroupsMockUsers < ActiveRecord::Migration[6.1]
   def change
-    create_table :mock_groups_users, id: false do | t |
-      t.references :mock_group, foreign_key: true, type: :int8, index: true, null: false
-      t.references :mock_user,                     type: :uuid, index: true, null: false, primary_key: :primary_key
-
-      # The 'foreign_key:' option (used above) only works for 'id' column names
-      # but the test data has a column named 'primary_key' for 'mock_users'.
-      #
-      t.foreign_key :mock_users, primary_key: :primary_key
+    create_join_table :mock_groups, :mock_users do |t|
+      t.index [:mock_group_id, :mock_user_id]
+      t.index [:mock_user_id, :mock_group_id]
     end
   end
 end

data/spec/apps/dummy/db/schema.rb

@@ -24,26 +24,19 @@ ActiveRecord::Schema.define(version: 2021_03_08_044214) do
 
   create_table "mock_groups_users", id: false, force: :cascade do |t|
     t.bigint "mock_group_id", null: false
-    t.uuid "mock_user_id", null: false
-    t.index ["mock_group_id"], name: "index_mock_groups_users_on_mock_group_id"
-    t.index ["mock_user_id"], name: "index_mock_groups_users_on_mock_user_id"
+    t.bigint "mock_user_id", null: false
+    t.index ["mock_group_id", "mock_user_id"], name: "index_mock_groups_users_on_mock_group_id_and_mock_user_id"
+    t.index ["mock_user_id", "mock_group_id"], name: "index_mock_groups_users_on_mock_user_id_and_mock_group_id"
   end
 
-  create_table "mock_users", primary_key: "primary_key", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t|
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
+  create_table "mock_users", force: :cascade do |t|
     t.text "scim_uid"
     t.text "username"
-    t.text "password"
     t.text "first_name"
     t.text "last_name"
     t.text "work_email_address"
     t.text "home_email_address"
     t.text "work_phone_number"
-    t.text "organization"
-    t.text "department"
   end
 
-  add_foreign_key "mock_groups_users", "mock_groups"
-  add_foreign_key "mock_groups_users", "mock_users", primary_key: "primary_key"
 end

data/spec/controllers/scimitar/application_controller_spec.rb

@@ -24,7 +24,7 @@ RSpec.describe Scimitar::ApplicationController do
       get :index, params: { format: :scim }
       expect(response).to be_ok
       expect(JSON.parse(response.body)).to eql({ 'message' => 'cool, cool!' })
-      expect(response.headers['WWW-Authenticate']).to eql('Basic')
+      expect(response.headers['WWW_AUTHENTICATE']).to eql('Basic')
     end
 
     it 'renders failure with bad password' do
@@ -84,61 +84,7 @@ RSpec.describe Scimitar::ApplicationController do
       get :index, params: { format: :scim }
       expect(response).to be_ok
       expect(JSON.parse(response.body)).to eql({ 'message' => 'cool, cool!' })
-      expect(response.headers['WWW-Authenticate']).to eql('Bearer')
-    end
-
-    it 'renders failure with bad token' do
-      request.env['HTTP_AUTHORIZATION'] = 'Bearer Invalid'
-
-      get :index, params: { format: :scim }
-      expect(response).not_to be_ok
-    end
-
-    it 'renders failure with blank token' do
-      request.env['HTTP_AUTHORIZATION'] = 'Bearer'
-
-      get :index, params: { format: :scim }
-      expect(response).not_to be_ok
-    end
-
-    it 'renders failure with missing header' do
-      get :index, params: { format: :scim }
-      expect(response).not_to be_ok
-    end
-  end
-
-  context 'authenticator evaluated within controller context' do
-
-    # Define a controller with a custom instance method 'valid_token'.
-    #
-    controller do
-      def index
-        render json: { 'message' => 'cool, cool!' }, format: :scim
-      end
-
-      def valid_token
-        'B'
-      end
-    end
-
-    # Call the above controller method from the token authenticator Proc,
-    # proving that it was executed in the controller's context.
-    #
-    before do
-      Scimitar.engine_configuration = Scimitar::EngineConfiguration.new(
-        token_authenticator: Proc.new do | token, options |
-          token == self.valid_token()
-        end
-      )
-    end
-
-    it 'renders success when valid creds are given' do
-      request.env['HTTP_AUTHORIZATION'] = 'Bearer B'
-
-      get :index, params: { format: :scim }
-      expect(response).to be_ok
-      expect(JSON.parse(response.body)).to eql({ 'message' => 'cool, cool!' })
-      expect(response.headers['WWW-Authenticate']).to eql('Bearer')
+      expect(response.headers['WWW_AUTHENTICATE']).to eql('Bearer')
     end
 
     it 'renders failure with bad token' do
@@ -223,74 +169,5 @@ RSpec.describe Scimitar::ApplicationController do
       expect(parsed_body).to include('status' => '500')
       expect(parsed_body).to include('detail' => 'Bang')
     end
-
-    context 'with an exception reporter' do
-      around :each do | example |
-        original_configuration = Scimitar.engine_configuration.exception_reporter
-        Scimitar.engine_configuration.exception_reporter = Proc.new do | exception |
-          @exception = exception
-        end
-        example.run()
-      ensure
-        Scimitar.engine_configuration.exception_reporter = original_configuration
-      end
-
-      context 'and "internal server error"' do
-        it 'is invoked' do
-          get :index, params: { format: :scim }
-
-          expect(@exception).to be_a(RuntimeError)
-          expect(@exception.message).to eql('Bang')
-        end
-      end
-
-      context 'and "not found"' do
-        controller do
-          def index
-            handle_resource_not_found(ActiveRecord::RecordNotFound.new(42))
-          end
-        end
-
-        it 'is invoked' do
-          get :index, params: { format: :scim }
-
-          expect(@exception).to be_a(ActiveRecord::RecordNotFound)
-          expect(@exception.message).to eql('42')
-        end
-      end
-
-      context 'and bad JSON' do
-        controller do
-          def index
-            begin
-              raise 'Hello'
-            rescue
-              raise ActionDispatch::Http::Parameters::ParseError
-            end
-          end
-        end
-
-        it 'is invoked' do
-          get :index, params: { format: :scim }
-
-          expect(@exception).to be_a(ActionDispatch::Http::Parameters::ParseError)
-          expect(@exception.message).to eql('Hello')
-        end
-      end
-
-      context 'and a bad content type' do
-        controller do
-          def index; end
-        end
-
-        it 'is invoked' do
-          request.headers['Content-Type'] = 'text/plain'
-          get :index
-
-          expect(@exception).to be_a(Scimitar::ErrorResponse)
-          expect(@exception.message).to eql('Only application/scim+json type is accepted.')
-        end
-      end
-    end # "context 'exception reporter' do"
-  end # "context 'error handling' do"
+  end
 end

data/spec/controllers/scimitar/resource_types_controller_spec.rb

@@ -9,8 +9,8 @@ RSpec.describe Scimitar::ResourceTypesController do
     it 'renders the resource type for user' do
       get :index, format: :scim
       response_hash = JSON.parse(response.body)
-      expected_response = [ Scimitar::Resources::User.resource_type(scim_resource_type_url(name: 'User', test: 1)),
-                            Scimitar::Resources::Group.resource_type(scim_resource_type_url(name: 'Group', test: 1))
+      expected_response = [ Scimitar::Resources::User.resource_type(scim_resource_type_url(name: 'User')),
+                            Scimitar::Resources::Group.resource_type(scim_resource_type_url(name: 'Group'))
       ].to_json
 
       response_hash = JSON.parse(response.body)

data/spec/controllers/scimitar/schemas_controller_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 RSpec.describe Scimitar::SchemasController do
-  routes { Scimitar::Engine.routes }
 
   before(:each) { allow(controller).to receive(:authenticated?).and_return(true) }
 
@@ -15,9 +14,9 @@ RSpec.describe Scimitar::SchemasController do
       get :index, params: { format: :scim }
       expect(response).to be_ok
       parsed_body = JSON.parse(response.body)
-      expect(parsed_body.length).to eql(3)
+      expect(parsed_body.length).to eql(2)
       schema_names = parsed_body.map {|schema| schema['name']}
-      expect(schema_names).to match_array(['User', 'ExtendedUser', 'Group'])
+      expect(schema_names).to match_array(['User', 'Group'])
     end
 
     it 'returns only the User schema when its id is provided' do
@@ -27,13 +26,6 @@ RSpec.describe Scimitar::SchemasController do
       expect(parsed_body['name']).to eql('User')
     end
 
-    it 'includes the controller customised schema location' do
-      get :index, params: { name: Scimitar::Schema::User.id, format: :scim }
-      expect(response).to be_ok
-      parsed_body = JSON.parse(response.body)
-      expect(parsed_body.dig('meta', 'location')).to eq scim_schemas_url(name: Scimitar::Schema::User.id, test: 1)
-    end
-
     it 'returns only the Group schema when its id is provided' do
       get :index, params: { name: Scimitar::Schema::Group.id, format: :scim }
       expect(response).to be_ok

data/spec/models/scimitar/complex_types/address_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 RSpec.describe Scimitar::ComplexTypes::Address do
   context '#as_json' do
-    it 'assumes no defaults' do
-      expect(described_class.new.as_json).to eq({})
+    it 'assumes a type of "work" as a default' do
+      expect(described_class.new.as_json).to eq('type' => 'work')
     end
 
     it 'allows a custom address type' do
@@ -11,8 +11,9 @@ RSpec.describe Scimitar::ComplexTypes::Address do
     end
 
     it 'shows the set address' do
-      expect(described_class.new(country: 'NZ').as_json).to eq('country' => 'NZ')
+      expect(described_class.new(country: 'NZ').as_json).to eq('type' => 'work', 'country' => 'NZ')
     end
   end
 
 end
+

data/spec/models/scimitar/complex_types/email_spec.rb

@@ -18,4 +18,6 @@ RSpec.describe Scimitar::ComplexTypes::Email do
       expect(described_class.new(value: 'a@b.c').as_json).to eq('value' => 'a@b.c')
     end
   end
+
 end
+

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