keycloak-admin 2.0.1 → 2.0.2

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

data/spec/client/client_spec.rb

@@ -1,101 +0,0 @@
-RSpec.describe KeycloakAdmin::Client do
-  describe "#server_url" do
-    def client_with_server_url(server_url)
-      configuration = KeycloakAdmin::Configuration.new
-      configuration.server_url = server_url
-      KeycloakAdmin::Client.new(configuration)
-    end
-
-    it "returns the configured url untouched when it has no trailing slash" do
-      expect(client_with_server_url("http://auth.service.io/auth").server_url).to eql "http://auth.service.io/auth"
-    end
-
-    it "strips a trailing slash so built paths stay normalized" do
-      expect(client_with_server_url("http://auth.service.io/auth/").server_url).to eql "http://auth.service.io/auth"
-    end
-
-    it "strips repeated trailing slashes" do
-      expect(client_with_server_url("http://localhost:8080///").server_url).to eql "http://localhost:8080"
-    end
-
-    it "returns nil when no url is configured" do
-      expect(client_with_server_url(nil).server_url).to be_nil
-    end
-  end
-
-  describe "#current_token" do
-    def token(expires_in)
-      KeycloakAdmin::TokenRepresentation.new(
-        "access_token", "bearer", expires_in, "refresh_token",
-        "refresh_expires_in", "id_token", "not_before_policy", "session_state"
-      )
-    end
-
-    it "fetches once and reuses the cached token across Client instances sharing the same configuration" do
-      configuration = KeycloakAdmin.config
-      configuration.clear_cached_token!
-      allow_any_instance_of(KeycloakAdmin::TokenClient).to receive(:get).and_return(token(3600))
-
-      first  = KeycloakAdmin::Client.new(configuration).current_token
-      second = KeycloakAdmin::Client.new(configuration).current_token
-
-      expect(first).to be second
-      expect(second).to be second
-    end
-
-    it "fetches a new token once the cached one has expired" do
-      configuration = KeycloakAdmin.config
-      configuration.clear_cached_token!
-      # allow_any_instance_of's sequential and_return(a, b) tracks call count per instance,
-      # and a fresh TokenClient is built on every fetch, so a plain external counter is used
-      # instead to force the first fetch to be pre-expired and the second one not to be.
-      call_count = 0
-      allow_any_instance_of(KeycloakAdmin::TokenClient).to receive(:get) do
-        call_count += 1
-        call_count == 1 ? token(5) : token(3600)
-      end
-
-      expired_immediately = KeycloakAdmin::Client.new(configuration).current_token
-      refreshed            = KeycloakAdmin::Client.new(configuration).current_token
-
-      expect(expired_immediately).to_not be refreshed
-      expect(call_count).to eq 2
-    end
-  end
-
-  describe "#resource" do
-    it "builds a Resource with the configuration's faraday_options and logger" do
-      configuration = KeycloakAdmin::Configuration.new
-      configuration.faraday_options = { timeout: 5 }
-      configuration.logger          = Logger.new(IO::NULL)
-      client = KeycloakAdmin::Client.new(configuration)
-
-      expect(KeycloakAdmin::Resource).to receive(:new).with("http://x", { timeout: 5 }, configuration.logger)
-
-      client.send(:resource, "http://x")
-    end
-  end
-
-  describe "#execute_http" do
-    let(:realm_name) { "valid-realm" }
-    before(:each) do
-      @client = KeycloakAdmin::Client.new(KeycloakAdmin.config)
-    end
-
-    it "handles timeout" do
-      expect do
-        @client.execute_http do
-          raise Faraday::TimeoutError.new
-        end
-      end.to raise_error(Faraday::TimeoutError)
-    end
-
-    it "handles response exception" do
-      expect do
-        @client.execute_http do
-          raise Faraday::ServerError.new("boom", status: 500, body: "Server error")
-        end
-      end.to raise_error("Keycloak: The request failed with response code 500 and message: Server error")
-    end
-  end
-end

data/spec/client/configurable_token_client_spec.rb

@@ -1,34 +0,0 @@
-RSpec.describe KeycloakAdmin::ConfigurableTokenClient do
-  describe "#initialize" do
-    context "when realm_name is defined" do
-      let(:realm_name) { "master" }
-      it "does not raise any error" do
-        expect {
-          KeycloakAdmin.realm(realm_name).configurable_token
-        }.to_not raise_error
-      end
-    end
-
-    context "when realm_name is not defined" do
-      let(:realm_name) { nil }
-      it "raises any error" do
-        expect {
-          KeycloakAdmin.realm(realm_name).configurable_token
-        }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#token_url" do
-    let(:realm_name) { "valid-realm" }
-    let(:user_id)    { nil }
-
-    before(:each) do
-      @built_url = KeycloakAdmin.realm(realm_name).configurable_token.token_url
-    end
-
-    it "return a proper url with the realm name" do
-      expect(@built_url).to eq "http://auth.service.io/auth/realms/valid-realm/configurable-token"
-    end
-  end
-end