keycloak-admin 2.0.0 → 2.0.2

data/spec/client/client_client_spec.rb

@@ -1,133 +0,0 @@
-RSpec.describe KeycloakAdmin::ClientClient do
-  describe "#clients_url" do
-    let(:realm_name) { "valid-realm" }
-    let(:client_id)    { nil }
-
-    before(:each) do
-      @built_url = KeycloakAdmin.realm(realm_name).clients.clients_url(client_id)
-    end
-
-    context "when client_id is not defined" do
-      let(:client_id) { nil }
-      it "return a proper url without client id" do
-        expect(@built_url).to eq "http://auth.service.io/auth/admin/realms/valid-realm/clients"
-      end
-    end
-
-    context "when client_id is defined" do
-      let(:client_id) { "95985b21-d884-4bbd-b852-cb8cd365afc2" }
-      it "return a proper url with the client id" do
-        expect(@built_url).to eq "http://auth.service.io/auth/admin/realms/valid-realm/clients/95985b21-d884-4bbd-b852-cb8cd365afc2"
-      end
-    end
-  end
-
-  describe "#get" do
-    let(:realm_name) { "valid-realm" }
-    let(:id) { "test_client_id" }
-    let(:client_name) { "test_client_name" }
-
-    before(:each) do
-      @client_client = KeycloakAdmin.realm(realm_name).clients
-
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get).and_return '{"id":"test_client_id","name":"test_client_name"}'
-    end
-
-    it "finds a client" do
-      client = @client_client.get(id)
-      expect(client.name).to eq client_name
-      expect(client.id).to eq id
-    end
-  end
-
-  describe "#find_by_client_id" do
-    let(:realm_name) { "valid-realm" }
-    let(:client_id) { "my_client_id" }
-    let(:client_name) { "test_client_name" }
-
-    before(:each) do
-      @client_client = KeycloakAdmin.realm(realm_name).clients
-
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get).and_return '[{"id":"test_client_id","clientId": "my_client_id","name":"test_client_name"},{"id":"test_client_id_2","clientId":"client_id_2","name":"test_client_name_2"}]'
-    end
-
-    it "finds a client it has" do
-      client = @client_client.find_by_client_id(client_id)
-      expect(client.name).to eq client_name
-      expect(client.client_id).to eq client_id
-    end
-
-    it "returns nil if it doesn't have the client" do
-      client = @client_client.find_by_client_id("client_id_3")
-      expect(client).to be_nil
-    end
-  end
-
-  describe "#list" do
-    let(:realm_name) { "valid-realm" }
-
-    before(:each) do
-      @client_client = KeycloakAdmin.realm(realm_name).clients
-
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get).and_return '[{"id":"test_client_id","name":"test_client_name"}]'
-    end
-
-    it "lists clients" do
-      clients = @client_client.list
-      expect(clients.length).to eq 1
-      expect(clients[0].name).to eq "test_client_name"
-    end
-
-    it "passes rest client options" do
-      faraday_options = {timeout: 10}
-      allow_any_instance_of(KeycloakAdmin::Configuration).to receive(:faraday_options).and_return faraday_options
-
-      expect(KeycloakAdmin::Resource).to receive(:new).with(
-        "http://auth.service.io/auth/admin/realms/valid-realm/clients", faraday_options).and_call_original
-
-      clients = @client_client.list
-      expect(clients.length).to eq 1
-      expect(clients[0].name).to eq "test_client_name"
-    end
-  end
-
-  describe "#update" do
-    let(:realm_name) { "valid-realm" }
-    let(:client) { KeycloakAdmin::ClientRepresentation.from_hash({ "id" => "test_client_id", "clientId" => "my-client", "name" => "old_name" }) }
-
-    before(:each) do
-      @client_client = KeycloakAdmin.realm(realm_name).clients
-
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:put).and_return ''
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get).and_return '{"id":"test_client_id", "clientId": "my-client","name":"new_name"}'
-    end
-
-    it "updates a client" do
-      updated_client = @client_client.update(client)
-
-      expect(updated_client.name).to eq "new_name"
-    end
-  end
-
-  describe "#delete" do
-    let(:realm_name) { "valid-realm" }
-
-    before(:each) do
-      @client_client = KeycloakAdmin.realm(realm_name).clients
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:delete).and_return ''
-    end
-
-    it "passes rest client options" do
-      faraday_options = {timeout: 10}
-      allow_any_instance_of(KeycloakAdmin::Configuration).to receive(:faraday_options).and_return faraday_options
-      expect(KeycloakAdmin::Resource).to receive(:new).with(
-        "http://auth.service.io/auth/admin/realms/valid-realm/clients/95b45037-3980-404c-ba12-784fa1baf2c2", faraday_options).and_call_original
-      @client_client.delete("95b45037-3980-404c-ba12-784fa1baf2c2")
-    end
-  end
-end

data/spec/client/client_role_mappings_client_spec.rb

@@ -1,82 +0,0 @@
-RSpec.describe KeycloakAdmin::ClientRoleMappingsClient do
-  describe "#available_url" do
-    let(:realm_name) { "valid-realm" }
-    let(:user_id)    { "test_user" }
-    let(:client_id)  { "test_client" }
-
-    before(:each) do
-      @built_url = KeycloakAdmin.realm(realm_name).user(user_id).client_role_mappings(client_id).list_available_url
-    end
-
-    it "return a proper url" do
-      expect(@built_url).to eq "http://auth.service.io/auth/admin/realms/valid-realm/users/test_user/role-mappings/clients/test_client/available"
-    end
-  end
-
-  describe "#list_available" do
-    let(:realm_name) { "valid-realm" }
-    let(:user_id)    { "test_user" }
-    let(:client_id)  { "test_client" }
-
-    before(:each) do
-      @client_role_mappings_client = KeycloakAdmin.realm(realm_name).user(user_id).client_role_mappings(client_id)
-
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get).and_return '[{"id":"test_role_id","name":"test_role_name"}]'
-    end
-
-    it "lists roles" do
-      roles = @client_role_mappings_client.list_available
-      expect(roles.length).to eq 1
-      expect(roles[0].name).to eq "test_role_name"
-    end
-
-    it "passes rest client options" do
-      faraday_options = {timeout: 10}
-      allow_any_instance_of(KeycloakAdmin::Configuration).to receive(:faraday_options).and_return faraday_options
-
-      expect(KeycloakAdmin::Resource).to receive(:new).with(
-        "http://auth.service.io/auth/admin/realms/valid-realm/users/test_user/role-mappings/clients/test_client/available",
-        faraday_options
-      ).and_call_original
-
-      roles = @client_role_mappings_client.list_available
-      expect(roles.length).to eq 1
-      expect(roles[0].name).to eq "test_role_name"
-    end
-  end
-
-  describe "#save" do
-    let(:realm_name) { "valid-realm" }
-    let(:user_id)    { "test_user" }
-    let(:client_id)  { "test_client" }
-    let(:role_list) { [
-      KeycloakAdmin::RoleRepresentation.from_hash(
-        "name" => "test_role_name",
-        "composite" => false,
-        "clientRole" => false
-      )
-    ] }
-
-    before(:each) do
-      @client_role_mappings_client = KeycloakAdmin.realm(realm_name).user(user_id).client_role_mappings(client_id)
-
-      stub_token_client
-      expect_any_instance_of(KeycloakAdmin::Resource).to receive(:post).with(role_list.to_json, anything)
-    end
-
-    it "saves client role mappings" do
-      @client_role_mappings_client.save(role_list)
-    end
-
-    it "passes rest client options" do
-      faraday_options = {timeout: 10}
-      allow_any_instance_of(KeycloakAdmin::Configuration).to receive(:faraday_options).and_return faraday_options
-
-      expect(KeycloakAdmin::Resource).to receive(:new).with(
-        "http://auth.service.io/auth/admin/realms/valid-realm/users/test_user/role-mappings/clients/test_client", faraday_options).and_call_original
-
-      @client_role_mappings_client.save(role_list)
-    end
-  end
-end

data/spec/client/client_scope_client_spec.rb

@@ -1,220 +0,0 @@
-RSpec.describe KeycloakAdmin::ClientScopeClient do
-  let(:realm_name)      { "valid-realm" }
-  let(:client_scope_id) { "valid-scope-id" }
-
-  let(:scope_json) do
-    <<~JSON
-      {"id":"valid-scope-id","name":"my-scope","description":"A test scope","protocol":"openid-connect","attributes":{"display.on.consent.screen":"true","include.in.token.scope":"true"}}
-    JSON
-  end
-
-  let(:scope_with_mappers_json) do
-    <<~JSON
-      {"id":"valid-scope-id","name":"my-scope","description":"A test scope","protocol":"openid-connect","attributes":{},"protocolMappers":[{"id":"mapper-id","name":"my-claim","protocol":"openid-connect","protocolMapper":"oidc-hardcoded-claim-mapper","config":{"claim.name":"my_claim","claim.value":"bar","access.token.claim":"true"}}]}
-    JSON
-  end
-
-  describe "#initialize" do
-    context "when realm_name is defined" do
-      it "does not raise any error" do
-        expect { KeycloakAdmin.realm(realm_name).client_scopes }.to_not raise_error
-      end
-    end
-
-    context "when realm_name is not defined" do
-      it "raises an argument error" do
-        expect { KeycloakAdmin.realm(nil).client_scopes }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#list" do
-    before(:each) do
-      @client = KeycloakAdmin.realm(realm_name).client_scopes
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get).and_return stub_response
-    end
-
-    context "with one scope" do
-      let(:stub_response) { "[#{scope_json}]" }
-
-      it "returns one scope" do
-        expect(@client.list.size).to eq 1
-      end
-
-      it "returns the correct scope attributes" do
-        expect(@client.list.first).to have_attributes(
-          id:          "valid-scope-id",
-          name:        "my-scope",
-          description: "A test scope",
-          protocol:    "openid-connect"
-        )
-      end
-
-      it "returns attributes map" do
-        expect(@client.list.first.attributes).to include(
-          "display.on.consent.screen" => "true",
-          "include.in.token.scope"    => "true"
-        )
-      end
-    end
-
-    context "with multiple scopes" do
-      let(:second_scope_json) { '{"id":"other-scope-id","name":"other-scope","protocol":"openid-connect"}' }
-      let(:stub_response) { "[#{scope_json},#{second_scope_json}]" }
-
-      it "returns two scopes" do
-        expect(@client.list.size).to eq 2
-      end
-
-      it "includes both scope names" do
-        expect(@client.list.map(&:name)).to include("my-scope", "other-scope")
-      end
-    end
-  end
-
-  describe "#get" do
-    before(:each) do
-      @client = KeycloakAdmin.realm(realm_name).client_scopes
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get).and_return stub_response
-    end
-
-    context "without protocol mappers" do
-      let(:stub_response) { scope_json }
-
-      it "returns the correct id" do
-        expect(@client.get(client_scope_id).id).to eq "valid-scope-id"
-      end
-
-      it "returns the correct name" do
-        expect(@client.get(client_scope_id).name).to eq "my-scope"
-      end
-
-      it "returns the correct description" do
-        expect(@client.get(client_scope_id).description).to eq "A test scope"
-      end
-
-      it "returns the correct protocol" do
-        expect(@client.get(client_scope_id).protocol).to eq "openid-connect"
-      end
-
-      it "returns an empty protocolMappers list" do
-        expect(@client.get(client_scope_id).protocol_mappers).to eq []
-      end
-    end
-
-    context "with protocol mappers" do
-      let(:stub_response) { scope_with_mappers_json }
-
-      it "returns protocol mappers" do
-        expect(@client.get(client_scope_id).protocol_mappers.size).to eq 1
-      end
-
-      it "returns the correct mapper name" do
-        expect(@client.get(client_scope_id).protocol_mappers.first.name).to eq "my-claim"
-      end
-    end
-  end
-
-  describe "#create!" do
-    before(:each) do
-      @client = KeycloakAdmin.realm(realm_name).client_scopes
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:post).and_return ""
-    end
-
-    let(:scope_representation) do
-      scope             = KeycloakAdmin::ClientScopeRepresentation.new
-      scope.name        = "my-scope"
-      scope.description = "A test scope"
-      scope.protocol    = "openid-connect"
-      scope.attributes  = { "display.on.consent.screen" => "true", "include.in.token.scope" => "true" }
-      scope
-    end
-
-    it "creates successfully" do
-      expect(@client.create!(scope_representation)).to be true
-    end
-  end
-
-  describe "#save" do
-    before(:each) do
-      @client = KeycloakAdmin.realm(realm_name).client_scopes
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:put).and_return ""
-    end
-
-    let(:scope_representation) { KeycloakAdmin::ClientScopeRepresentation.from_hash(JSON.parse(scope_json)) }
-
-    it "calls put on the scope url" do
-      expect_any_instance_of(KeycloakAdmin::Resource).to receive(:put).with(anything, anything)
-      @client.save(scope_representation)
-    end
-
-    it "returns true" do
-      expect(@client.save(scope_representation)).to be true
-    end
-  end
-
-  describe "#search" do
-    let(:second_scope_json) { '{"id":"other-scope-id","name":"other-scope","protocol":"openid-connect"}' }
-
-    before(:each) do
-      @client = KeycloakAdmin.realm(realm_name).client_scopes
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get).and_return "[#{scope_json},#{second_scope_json}]"
-    end
-
-    context "when the name matches one scope" do
-      it "returns only the matching scope" do
-        expect(@client.search("my-scope").size).to eq 1
-      end
-
-      it "returns the correct scope" do
-        expect(@client.search("my-scope").first).to have_attributes(id: "valid-scope-id", name: "my-scope")
-      end
-    end
-
-    context "when the name is a partial match" do
-      it "returns all scopes containing the substring" do
-        expect(@client.search("scope").size).to eq 2
-      end
-    end
-
-    context "when no scope matches" do
-      it "returns an empty array" do
-        expect(@client.search("unknown")).to eq []
-      end
-    end
-  end
-
-  describe "#delete" do
-    before(:each) do
-      @client = KeycloakAdmin.realm(realm_name).client_scopes
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:delete).and_return ""
-    end
-
-    it "returns true" do
-      expect(@client.delete(client_scope_id)).to eq true
-    end
-  end
-
-  describe "#client_scopes_url" do
-    let(:client)   { KeycloakAdmin.realm(realm_name).client_scopes }
-    let(:base_url) { "http://auth.service.io/auth/admin/realms/valid-realm/client-scopes" }
-
-    context "without a client_scope_id" do
-      it "returns the base url" do
-        expect(client.client_scopes_url).to eq base_url
-      end
-    end
-
-    context "with a client_scope_id" do
-      it "returns the url with client_scope_id appended" do
-        expect(client.client_scopes_url(client_scope_id)).to eq "#{base_url}/valid-scope-id"
-      end
-    end
-  end
-end

data/spec/client/client_scope_protocol_mapper_client_spec.rb

@@ -1,230 +0,0 @@
-RSpec.describe KeycloakAdmin::ClientScopeProtocolMapperClient do
-  let(:realm_name)      { "valid-realm" }
-  let(:client_scope_id) { "valid-scope-id" }
-  let(:mapper_id)       { "valid-mapper-id" }
-
-  let(:mapper_json) do
-    <<~JSON
-      {"id":"valid-mapper-id","name":"my-claim","protocol":"openid-connect","protocolMapper":"oidc-hardcoded-claim-mapper","config":{"claim.name":"my_claim","claim.value":"bar","access.token.claim":"true"}}
-    JSON
-  end
-
-  let(:audience_mapper_json) do
-    <<~JSON
-      {"protocol":"openid-connect","protocolMapper":"oidc-audience-mapper","name":"audience-config-rvw-123","config":{"included.client.audience":"","included.custom.audience":"https://api.example.com","id.token.claim":"false","access.token.claim":"true","lightweight.claim":"false","introspection.token.claim":"true"}}
-    JSON
-  end
-
-  describe "#initialize" do
-    context "when realm_name is defined" do
-      it "does not raise any error" do
-        expect { KeycloakAdmin.realm(realm_name).client_scope_protocol_mappers(client_scope_id) }.to_not raise_error
-      end
-    end
-
-    context "when realm_name is not defined" do
-      it "raises an argument error" do
-        expect { KeycloakAdmin.realm(nil).client_scope_protocol_mappers(client_scope_id) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#list" do
-    before(:each) do
-      @client = KeycloakAdmin.realm(realm_name).client_scope_protocol_mappers(client_scope_id)
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get).and_return stub_response
-    end
-
-    context "with a hardcoded claim mapper" do
-      let(:stub_response) { "[#{mapper_json}]" }
-
-      it "returns one mapper" do
-        expect(@client.list.size).to eq 1
-      end
-
-      it "returns the correct mapper attributes" do
-        expect(@client.list.first).to have_attributes(id: "valid-mapper-id", name: "my-claim", protocol: "openid-connect", protocolMapper: "oidc-hardcoded-claim-mapper")
-      end
-    end
-
-    context "with an audience mapper" do
-      let(:stub_response) { "[#{audience_mapper_json}]" }
-
-      it "returns one mapper" do
-        expect(@client.list.size).to eq 1
-      end
-
-      it "returns the correct mapper attributes" do
-        expect(@client.list.first).to have_attributes(name: "audience-config-rvw-123", protocol: "openid-connect", protocolMapper: "oidc-audience-mapper")
-      end
-    end
-
-    context "with multiple mappers" do
-      let(:stub_response) { "[#{mapper_json},#{audience_mapper_json}]" }
-
-      it "returns two mappers" do
-        expect(@client.list.size).to eq 2
-      end
-
-      it "includes both mapper names" do
-        expect(@client.list.map(&:name)).to include("my-claim", "audience-config-rvw-123")
-      end
-    end
-  end
-
-  describe "#get" do
-    before(:each) do
-      @client = KeycloakAdmin.realm(realm_name).client_scope_protocol_mappers(client_scope_id)
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get).and_return stub_response
-    end
-
-    context "with a hardcoded claim mapper" do
-      let(:stub_response) { mapper_json }
-
-      it "returns the correct id" do
-        expect(@client.get(mapper_id).id).to eq "valid-mapper-id"
-      end
-
-      it "returns the correct name" do
-        expect(@client.get(mapper_id).name).to eq "my-claim"
-      end
-
-      it "returns the correct protocol" do
-        expect(@client.get(mapper_id).protocol).to eq "openid-connect"
-      end
-
-      it "returns the correct protocolMapper" do
-        expect(@client.get(mapper_id).protocolMapper).to eq "oidc-hardcoded-claim-mapper"
-      end
-    end
-
-    context "with an audience mapper" do
-      let(:stub_response) { audience_mapper_json }
-
-      it "returns the correct name" do
-        expect(@client.get(mapper_id).name).to eq "audience-config-rvw-123"
-      end
-
-      it "returns the correct protocol" do
-        expect(@client.get(mapper_id).protocol).to eq "openid-connect"
-      end
-
-      it "returns the correct protocolMapper" do
-        expect(@client.get(mapper_id).protocolMapper).to eq "oidc-audience-mapper"
-      end
-
-      it "returns the correct config" do
-        expect(@client.get(mapper_id).config).to include(
-          "included.custom.audience"  => "https://api.example.com",
-          "access.token.claim"        => "true",
-          "introspection.token.claim" => "true",
-          "id.token.claim"            => "false"
-        )
-      end
-    end
-  end
-
-  describe "#create!" do
-    before(:each) do
-      @client = KeycloakAdmin.realm(realm_name).client_scope_protocol_mappers(client_scope_id)
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:post).and_return stub_response
-    end
-
-    context "with a hardcoded claim mapper" do
-      let(:stub_response) { mapper_json }
-      let(:mapper_representation) do
-        mapper = KeycloakAdmin::ProtocolMapperRepresentation.new
-        mapper.name           = "my-claim"
-        mapper.protocol       = "openid-connect"
-        mapper.protocolMapper = "oidc-hardcoded-claim-mapper"
-        mapper.config         = { "claim.name" => "my_claim", "claim.value" => "bar", "access.token.claim" => "true" }
-        mapper
-      end
-
-      it "creates successfully" do
-        expect(@client.create!(mapper_representation)).to be true
-      end
-    end
-
-    context "with an audience mapper" do
-      let(:stub_response)         { audience_mapper_json }
-      let(:mapper_representation) do
-        mapper = KeycloakAdmin::ProtocolMapperRepresentation.new
-        mapper.name           = "audience-config-rvw-123"
-        mapper.protocol       = "openid-connect"
-        mapper.protocolMapper = "oidc-audience-mapper"
-        mapper.config         = {
-          "included.client.audience"  => "",
-          "included.custom.audience"  => "https://api.example.com",
-          "id.token.claim"            => "false",
-          "access.token.claim"        => "true",
-          "lightweight.claim"         => "false",
-          "introspection.token.claim" => "true"
-        }
-        mapper
-      end
-
-      it "creates successfully" do
-        expect(@client.create!(mapper_representation)).to be true
-      end
-    end
-  end
-
-  describe "#save" do
-    before(:each) do
-      @client = KeycloakAdmin.realm(realm_name).client_scope_protocol_mappers(client_scope_id)
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:put).and_return ""
-    end
-
-    context "with a hardcoded claim mapper" do
-      let(:mapper_representation) { KeycloakAdmin::ProtocolMapperRepresentation.from_hash(JSON.parse(mapper_json)) }
-
-      it "calls put on the mapper url" do
-        expect_any_instance_of(KeycloakAdmin::Resource).to receive(:put).with(anything, anything)
-        @client.save(mapper_representation)
-      end
-    end
-
-    context "with an audience mapper" do
-      let(:mapper_representation) { KeycloakAdmin::ProtocolMapperRepresentation.from_hash(JSON.parse(audience_mapper_json)) }
-
-      it "calls put on the mapper url" do
-        expect_any_instance_of(KeycloakAdmin::Resource).to receive(:put).with(anything, anything)
-        @client.save(mapper_representation)
-      end
-    end
-  end
-
-  describe "#delete" do
-    before(:each) do
-      @client = KeycloakAdmin.realm(realm_name).client_scope_protocol_mappers(client_scope_id)
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:delete).and_return ""
-    end
-
-    it "returns true" do
-      expect(@client.delete(mapper_id)).to eq true
-    end
-  end
-
-  describe "#protocol_mappers_url" do
-    let(:client)   { KeycloakAdmin.realm(realm_name).client_scope_protocol_mappers(client_scope_id) }
-    let(:base_url) { "http://auth.service.io/auth/admin/realms/valid-realm/client-scopes/valid-scope-id/protocol-mappers/models" }
-
-    context "without a mapper_id" do
-      it "returns the base url" do
-        expect(client.protocol_mappers_url).to eq base_url
-      end
-    end
-
-    context "with a mapper_id" do
-      it "returns the url with mapper_id appended" do
-        expect(client.protocol_mappers_url(mapper_id)).to eq "#{base_url}/valid-mapper-id"
-      end
-    end
-  end
-end