keycloak-admin 2.0.1 → 2.0.2

data/spec/client/realm_client_spec.rb

@@ -1,155 +0,0 @@
-RSpec.describe KeycloakAdmin::RealmClient do
-  describe "#realm_url" do
-
-    let(:realm_name) { nil }
-
-    before(:each) do
-      @built_url = KeycloakAdmin.realm(realm_name).realm_url
-    end
-
-    context "when realm_name is defined" do
-      let(:realm_name) { "master2" }
-      it "return a proper url with realm_name" do
-        expect(@built_url).to eq "http://auth.service.io/auth/realms/master2"
-      end
-    end
-
-    context "when realm_name is not defined" do
-      let(:realm_name) { nil }
-      it "return a proper url without realm_name" do
-        expect(@built_url).to eq "http://auth.service.io/auth/realms"
-      end
-    end
-  end
-
-  describe "#admin_realm_url" do
-
-    let(:realm_name) { nil }
-
-    before(:each) do
-      @built_url = KeycloakAdmin.realm(realm_name).realm_admin_url
-    end
-
-    context "when realm_name is defined" do
-      let(:realm_name) { "master2" }
-      it "return a proper url with realm_name" do
-        expect(@built_url).to eq "http://auth.service.io/auth/admin/realms/master2"
-      end
-    end
-
-    context "when realm_name is not defined" do
-      let(:realm_name) { nil }
-      it "return a proper url without realm_name" do
-        expect(@built_url).to eq "http://auth.service.io/auth/admin/realms"
-      end
-    end
-  end
-
-  describe "#list" do
-    before(:each) do
-      @realm_client = KeycloakAdmin.realm('master')
-
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get).and_return '[{"id":"test_realm","realm":"test_realm"}]'
-    end
-
-    it "lists realms" do
-      realms = @realm_client.list
-      expect(realms.length).to eq 1
-      expect(realms[0].realm).to eq "test_realm"
-    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", faraday_options, anything).and_call_original
-
-      realms = @realm_client.list
-      expect(realms.length).to eq 1
-      expect(realms[0].realm).to eq "test_realm"
-    end
-  end
-
-  describe "#delete" do
-    let(:realm_name) { "valid-realm" }
-
-    before(:each) do
-      @realm_client = KeycloakAdmin.realm(realm_name)
-
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:delete)
-    end
-
-    it "delete realm" do
-      expect(@realm_client.delete).to be_truthy
-    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", faraday_options, anything).and_call_original
-
-      expect(@realm_client.delete).to be_truthy
-    end
-  end
-
-  describe "#save" do
-    let(:realm_name) { "valid-realm" }
-    let(:realm) { KeycloakAdmin::RealmRepresentation.from_hash(
-      "id" => realm_name,
-      "realm" => realm_name
-    )}
-
-    before(:each) do
-      @realm_client = KeycloakAdmin.realm(nil)
-
-      stub_token_client
-
-      expect_any_instance_of(KeycloakAdmin::Resource).to receive(:post).with(realm.to_json, anything)
-    end
-
-    it "saves a realm" do
-      @realm_client.save(realm)
-    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", faraday_options, anything).and_call_original
-
-      @realm_client.save(realm)
-    end
-  end
-
-  describe "#update" do
-    let(:realm_name) { "valid-realm" }
-    let(:realm_json) { { smtpServer: { host: 'test_host' } } }
-
-    before(:each) do
-      @realm_client = KeycloakAdmin.realm(realm_name)
-
-      stub_token_client
-      expect_any_instance_of(KeycloakAdmin::Resource).to receive(:put).with(realm_json.to_json, anything)
-    end
-
-    it "updates a realm" do
-      @realm_client.update(realm_json)
-    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", faraday_options, anything).and_call_original
-
-      @realm_client.update(realm_json)
-    end
-  end
-end

data/spec/client/resource_spec.rb

@@ -1,223 +0,0 @@
-RSpec.describe KeycloakAdmin::Resource do
-  # A real, mutable stand-in for the Faraday::Request builder yielded by
-  # connection.get/post/put/delete { |req| ... }.
-  FakeRequest = Struct.new(:params, :headers) do
-    attr_accessor :body
-  end
-
-  let(:fake_request)  { FakeRequest.new({}, {}) }
-  let(:fake_response) { double(status: 200, body: "ok", headers: {}, reason_phrase: "OK") }
-
-  def stub_connection(resource, verb)
-    connection = double
-    allow(connection).to receive(verb) do |&block|
-      block.call(fake_request) if block
-      fake_response
-    end
-    allow(resource).to receive(:connection).and_return(connection)
-    connection
-  end
-
-  describe "#connection (the real Faraday connection, not stubbed)" do
-    def middleware_classes(resource)
-      resource.send(:connection).builder.handlers
-    end
-
-    it "does not register the logger middleware when no logger is configured" do
-      resource = KeycloakAdmin::Resource.new("http://example.com")
-      expect(middleware_classes(resource)).to_not include(Faraday::Response::Logger)
-    end
-
-    it "registers the logger middleware when a logger is configured" do
-      resource = KeycloakAdmin::Resource.new("http://example.com", {}, Logger.new(IO::NULL))
-      expect(middleware_classes(resource)).to include(Faraday::Response::Logger)
-    end
-
-    it "orders :raise_error before :logger, so a response is logged even when it raises" do
-      resource = KeycloakAdmin::Resource.new("http://example.com", {}, Logger.new(IO::NULL))
-      handlers = middleware_classes(resource)
-      expect(handlers.index(Faraday::Response::RaiseError)).to be < handlers.index(Faraday::Response::Logger)
-    end
-
-    it "logs method/url/status but never headers, since Faraday logs headers by default and one of them is the bearer token" do
-      log_output = StringIO.new
-      logger     = Logger.new(log_output)
-      stubs      = Faraday::Adapter::Test::Stubs.new
-      stubs.get(//) { [200, {}, "ok"] }
-
-      resource = KeycloakAdmin::Resource.new("http://example.com/x", {}, logger)
-      allow(resource).to receive(:connection) do
-        Faraday.new(url: "http://example.com/x") do |f|
-          f.response :raise_error
-          f.response :logger, logger, headers: false
-          f.adapter :test, stubs
-        end
-      end
-
-      resource.get(Authorization: "Bearer super-secret-token")
-
-      expect(log_output.string).to include("request: GET")
-      expect(log_output.string).to include("response: Status 200")
-      expect(log_output.string).to_not include("super-secret-token")
-      expect(log_output.string).to_not include("Authorization")
-    end
-  end
-
-  describe "#get" do
-    it "humanizes symbol header keys into HTTP header names" do
-      resource = KeycloakAdmin::Resource.new("http://example.com/users")
-      stub_connection(resource, :get)
-
-      resource.get(Authorization: "Bearer token", content_type: :json, accept: :json)
-
-      expect(fake_request.headers).to eq(
-        "Authorization" => "Bearer token",
-        "Content-Type"  => "application/json",
-        "Accept"        => "application/json"
-      )
-    end
-
-    it "extracts :params into the query string instead of sending it as a header" do
-      resource = KeycloakAdmin::Resource.new("http://example.com/users")
-      stub_connection(resource, :get)
-
-      resource.get(Authorization: "Bearer token", params: { search: "jean" })
-
-      expect(fake_request.params).to eq(search: "jean")
-      expect(fake_request.headers).to eq("Authorization" => "Bearer token")
-    end
-
-    it "passes a string content_type through unchanged" do
-      resource = KeycloakAdmin::Resource.new("http://example.com/users")
-      stub_connection(resource, :get)
-
-      resource.get(content_type: "application/x-www-form-urlencoded")
-
-      expect(fake_request.headers["Content-Type"]).to eq "application/x-www-form-urlencoded"
-    end
-
-    it "does not set a body" do
-      resource = KeycloakAdmin::Resource.new("http://example.com/users")
-      stub_connection(resource, :get)
-
-      resource.get({})
-
-      expect(fake_request.body).to be_nil
-    end
-
-    it "wraps the Faraday response in a KeycloakAdmin::Response" do
-      resource = KeycloakAdmin::Resource.new("http://example.com/users")
-      stub_connection(resource, :get)
-
-      expect(resource.get({})).to be_a KeycloakAdmin::Response
-    end
-  end
-
-  describe "#post" do
-    it "sends a pre-serialized string payload as the body unchanged" do
-      resource = KeycloakAdmin::Resource.new("http://example.com/users")
-      stub_connection(resource, :post)
-
-      resource.post('{"username":"jean"}', content_type: :json)
-
-      expect(fake_request.body).to eq '{"username":"jean"}'
-      expect(fake_request.headers["Content-Type"]).to eq "application/json"
-    end
-
-    it "form-encodes a Hash payload" do
-      resource = KeycloakAdmin::Resource.new("http://example.com/users")
-      stub_connection(resource, :post)
-
-      resource.post({ email: "a@b.com", firstName: "Jean Yves" }, {})
-
-      expect(fake_request.body).to eq "email=a%40b.com&firstName=Jean+Yves"
-    end
-
-    it "stamps Content-Type: application/x-www-form-urlencoded for a Hash payload when none was set" do
-      resource = KeycloakAdmin::Resource.new("http://example.com/users")
-      stub_connection(resource, :post)
-
-      resource.post({ id: "42" }, {})
-
-      expect(fake_request.headers["Content-Type"]).to eq "application/x-www-form-urlencoded"
-    end
-
-    it "does not override an explicit Content-Type for a Hash payload" do
-      resource = KeycloakAdmin::Resource.new("http://example.com/users")
-      stub_connection(resource, :post)
-
-      resource.post({ id: "42" }, content_type: "application/vnd.custom+form")
-
-      expect(fake_request.headers["Content-Type"]).to eq "application/vnd.custom+form"
-    end
-  end
-
-  describe "#delete" do
-    it "sends no body and only the given headers" do
-      resource = KeycloakAdmin::Resource.new("http://example.com/users/1")
-      stub_connection(resource, :delete)
-
-      resource.delete(Authorization: "Bearer token")
-
-      expect(fake_request.body).to be_nil
-      expect(fake_request.headers).to eq("Authorization" => "Bearer token")
-    end
-  end
-
-  describe ".execute (RestClient::Request.execute equivalent)" do
-    it "dispatches an arbitrary method with a payload, including DELETE with a body" do
-      resource_instance = KeycloakAdmin::Resource.new("http://example.com/mappings")
-      allow(KeycloakAdmin::Resource).to receive(:new).and_return(resource_instance)
-      stub_connection(resource_instance, :delete)
-
-      KeycloakAdmin::Resource.execute(
-        method: :delete,
-        url: "http://example.com/mappings",
-        payload: '[{"id":"1"}]',
-        headers: { content_type: :json }
-      )
-
-      expect(fake_request.body).to eq '[{"id":"1"}]'
-      expect(fake_request.headers["Content-Type"]).to eq "application/json"
-    end
-
-    it "forwards non-method/url/payload/headers keys as connection options" do
-      resource_instance  = KeycloakAdmin::Resource.new("http://example.com/x")
-      expected_options   = { timeout: 5 }
-      stub_connection(resource_instance, :get)
-      expect(KeycloakAdmin::Resource).to receive(:new).with("http://example.com/x", expected_options, nil).and_return(resource_instance)
-
-      KeycloakAdmin::Resource.execute(method: :get, url: "http://example.com/x", headers: {}, timeout: 5)
-    end
-
-    it "extracts :logger and passes it positionally instead of leaving it in connection options" do
-      resource_instance = KeycloakAdmin::Resource.new("http://example.com/x")
-      logger             = Logger.new(IO::NULL)
-      stub_connection(resource_instance, :get)
-      expect(KeycloakAdmin::Resource).to receive(:new).with("http://example.com/x", {}, logger).and_return(resource_instance)
-
-      KeycloakAdmin::Resource.execute(method: :get, url: "http://example.com/x", headers: {}, logger: logger)
-    end
-  end
-
-  describe ".put (RestClient.put shorthand)" do
-    it "posts without requiring any connection options" do
-      resource_instance = KeycloakAdmin::Resource.new("http://example.com/x")
-      allow(KeycloakAdmin::Resource).to receive(:new).and_return(resource_instance)
-      stub_connection(resource_instance, :put)
-
-      KeycloakAdmin::Resource.put("http://example.com/x", "body", {})
-
-      expect(fake_request.body).to eq "body"
-    end
-
-    it "forwards the given logger to the underlying Resource" do
-      resource_instance = KeycloakAdmin::Resource.new("http://example.com/x")
-      logger             = Logger.new(IO::NULL)
-      stub_connection(resource_instance, :put)
-      expect(KeycloakAdmin::Resource).to receive(:new).with("http://example.com/x", {}, logger).and_return(resource_instance)
-
-      KeycloakAdmin::Resource.put("http://example.com/x", "body", {}, logger)
-    end
-  end
-end

data/spec/client/response_spec.rb

@@ -1,68 +0,0 @@
-RSpec.describe KeycloakAdmin::Response do
-  def fake_faraday_response(status: 200, body: "", headers: {}, reason_phrase: "OK")
-    double(status: status, body: body, headers: headers, reason_phrase: reason_phrase)
-  end
-
-  describe "body-as-string behavior (RestClient::Response was a String subclass)" do
-    it "behaves like the raw body string" do
-      response = KeycloakAdmin::Response.new(fake_faraday_response(body: '{"a":1}'))
-      expect(response).to eq '{"a":1}'
-      expect(JSON.parse(response)).to eq({ "a" => 1 })
-    end
-
-    it "supports String methods relied on by callers, e.g. #to_i" do
-      response = KeycloakAdmin::Response.new(fake_faraday_response(body: "42"))
-      expect(response.to_i).to eq 42
-    end
-
-    it "exposes #body returning the same content" do
-      response = KeycloakAdmin::Response.new(fake_faraday_response(body: "hello"))
-      expect(response.body).to eq "hello"
-    end
-  end
-
-  describe "#status / #code / #reason_phrase" do
-    it "exposes the HTTP status" do
-      response = KeycloakAdmin::Response.new(fake_faraday_response(status: 201))
-      expect(response.status).to eq 201
-      expect(response.code).to eq 201
-    end
-
-    it "exposes the reason phrase" do
-      response = KeycloakAdmin::Response.new(fake_faraday_response(reason_phrase: "Created"))
-      expect(response.reason_phrase).to eq "Created"
-    end
-  end
-
-  describe "#headers" do
-    it "symbolizes header names the way RestClient did (downcased, dash to underscore)" do
-      response = KeycloakAdmin::Response.new(fake_faraday_response(headers: { "Location" => "/users/42", "Content-Type" => "application/json" }))
-      expect(response.headers[:location]).to eq "/users/42"
-      expect(response.headers[:content_type]).to eq "application/json"
-    end
-
-    it "splits a single Set-Cookie header into a one-element array" do
-      response = KeycloakAdmin::Response.new(fake_faraday_response(headers: { "Set-Cookie" => "a=1; Path=/" }))
-      expect(response.headers[:set_cookie]).to eq ["a=1; Path=/"]
-    end
-
-    it "splits multiple Set-Cookie headers joined by Faraday's net_http adapter" do
-      joined = "KEYCLOAK_SESSION=abc; Path=/, KEYCLOAK_IDENTITY=def; Path=/, AUTH_SESSION_ID=ghi; Path=/"
-      response = KeycloakAdmin::Response.new(fake_faraday_response(headers: { "Set-Cookie" => joined }))
-      expect(response.headers[:set_cookie]).to eq [
-        "KEYCLOAK_SESSION=abc; Path=/",
-        "KEYCLOAK_IDENTITY=def; Path=/",
-        "AUTH_SESSION_ID=ghi; Path=/"
-      ]
-    end
-
-    it "does not split on a comma embedded in a cookie's own Expires attribute" do
-      joined = "a=1; Expires=Wed, 09 Jun 2027 10:18:14 GMT; Path=/, b=2; Path=/"
-      response = KeycloakAdmin::Response.new(fake_faraday_response(headers: { "Set-Cookie" => joined }))
-      expect(response.headers[:set_cookie]).to eq [
-        "a=1; Expires=Wed, 09 Jun 2027 10:18:14 GMT; Path=/",
-        "b=2; Path=/"
-      ]
-    end
-  end
-end

data/spec/client/role_client_spec.rb

@@ -1,79 +0,0 @@
-RSpec.describe KeycloakAdmin::RoleClient do
-  describe "#roles_url" do
-    let(:realm_name) { "valid-realm" }
-
-    it "return a proper url without role id" do
-      @built_url = KeycloakAdmin.realm(realm_name).roles.roles_url
-      expect(@built_url).to eq "http://auth.service.io/auth/admin/realms/valid-realm/roles"
-    end
-  end
-
-  describe "#role_id_url" do
-    let(:realm_name) { "valid-realm" }
-    let(:role_id) { "95985b21-d884-4bbd-b852-cb8cd365afc2" }
-
-    it "return a proper url with the role id" do
-      @built_url = KeycloakAdmin.realm(realm_name).roles.role_id_url(role_id)
-      expect(@built_url).to eq "http://auth.service.io/auth/admin/realms/valid-realm/roles-by-id/95985b21-d884-4bbd-b852-cb8cd365afc2"
-    end
-  end
-
-  describe "#list" do
-    let(:realm_name) { "valid-realm" }
-
-    before(:each) do
-      @role_client = KeycloakAdmin.realm(realm_name).roles
-
-      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 = @role_client.list
-      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/roles", faraday_options, anything).and_call_original
-
-      roles = @role_client.list
-      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(:role) { KeycloakAdmin::RoleRepresentation.from_hash(
-      "name" => "test_role_name",
-      "composite" => false,
-      "clientRole" => false
-    )}
-
-    before(:each) do
-      @role_client = KeycloakAdmin.realm(realm_name).roles
-
-      stub_token_client
-      expect_any_instance_of(KeycloakAdmin::Resource).to receive(:post).with(role.to_json, anything)
-    end
-
-    it "saves a role" do
-      @role_client.save(role)
-    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/roles", faraday_options, anything).and_call_original
-
-      @role_client.save(role)
-    end
-  end
-end

data/spec/client/role_mapper_client_spec.rb

@@ -1,113 +0,0 @@
-RSpec.describe KeycloakAdmin::RoleMapperClient do
-  describe "#available_url" do
-    let(:realm_name) { "valid-realm" }
-    let(:user_id)    { "test_user" }
-
-    before(:each) do
-      @built_url = KeycloakAdmin.realm(realm_name).user(user_id).role_mapper.realm_level_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/realm"
-    end
-  end
-
-  describe "#list" do
-    let(:realm_name) { "valid-realm" }
-    let(:user_id)    { "test_user" }
-
-    before(:each) do
-      @role_mapper_client = KeycloakAdmin.realm(realm_name).user(user_id).role_mapper
-
-      stub_token_client
-      allow_any_instance_of(KeycloakAdmin::Resource).to receive(:get)
-        .and_return '[{"id":"test_role_id","name":"test_role_name","composite": false}]'
-    end
-
-    it "list user realm-level role mappings" do
-      roles = @role_mapper_client.list
-      expect(roles.length).to eq 1
-      expect(roles[0].id).to eq "test_role_id"
-      expect(roles[0].name).to eq "test_role_name"
-      expect(roles[0].composite).to be false
-    end
-  end
-
-  describe "#save_realm_level" do
-    let(:realm_name) { "valid-realm" }
-    let(:user_id)    { "test_user" }
-    let(:role_list) { [
-      KeycloakAdmin::RoleRepresentation.from_hash(
-        "name" => "test_role_name",
-        "composite" => false,
-        "clientRole" => false
-      )
-    ] }
-
-    before(:each) do
-      @role_mapper_client = KeycloakAdmin.realm(realm_name).user(user_id).role_mapper
-
-      stub_token_client
-      expect_any_instance_of(KeycloakAdmin::Resource).to receive(:post).with(role_list.to_json, anything)
-    end
-
-    it "saves realm-elevel role mappings" do
-      @role_mapper_client.save_realm_level(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/realm", faraday_options, anything).and_call_original
-
-      @role_mapper_client.save_realm_level(role_list)
-    end
-  end
-
-  describe "#remove_realm_level" do
-    let(:realm_name) { "valid-realm" }
-    let(:user_id)    { "test_user" }
-    let(:role_list) { [
-      KeycloakAdmin::RoleRepresentation.from_hash(
-        "id" => "d9e3376b-f602-4086-8eee-89fea73c73ea"
-      )
-    ] }
-    let(:expected_url) { "http://auth.service.io/auth/admin/realms/valid-realm/users/test_user/role-mappings/realm" }
-
-    before(:each) do
-      @role_mapper_client = KeycloakAdmin.realm(realm_name).user(user_id).role_mapper
-
-      stub_token_client
-    end
-
-    it "removes realm-level role mappings" do
-      expect(KeycloakAdmin::Resource).to receive(:execute).with(
-        hash_including(
-          method: :delete,
-          url: expected_url,
-          payload: role_list.to_json
-        )
-      )
-
-      @role_mapper_client.remove_realm_level(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(:execute).with(
-        hash_including(
-          method: :delete,
-          url: expected_url,
-          payload: role_list.to_json,
-          timeout: 10
-        )
-      )
-
-      @role_mapper_client.remove_realm_level(role_list)
-    end
-  end
-end