diff --git a/.cspell/custom-dictionary.txt b/.cspell/custom-dictionary.txt index d09b639..702bc1c 100644 --- a/.cspell/custom-dictionary.txt +++ b/.cspell/custom-dictionary.txt @@ -65,7 +65,11 @@ PYTHONHTTPSVERIFY # Keycloak-specific ciba clusterless +eddsa +multivalued remembertochangeme +subcomponent +subcomponents # Molecule / Testing hspaans @@ -84,5 +88,17 @@ decomment # British spellings (from upstream Keycloak docs) recognises +# Integration test container/variable names +Ceciestes +myidpfromurl +myidprealm +myfed +myldap +rootgrp +subgrp +subsubgrp +subsubsubgrp +Untestes + # Other rmaster diff --git a/molecule/keycloak_modules/keycloak_authentication/verify.yml b/molecule/keycloak_modules/keycloak_authentication/verify.yml new file mode 100644 index 0000000..85e9df9 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_authentication/verify.yml @@ -0,0 +1,131 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_authentication +# Tests authentication flow CRUD: create from copy, create with conditional OTP, +# update config, verify config uniqueness via realm export, and delete. + +- name: Set auth flow test variables + ansible.builtin.set_fact: + keycloak_no_otp_required_pattern_original: 'X-Forwarded-For: 10\.[0-9\.:]+' + keycloak_no_otp_required_pattern_modified: 'X-Original-Forwarded-For: 10\.[0-9\.:]+' + +- name: Create auth flow from first broker login copy + middleware_automation.keycloak.keycloak_authentication: + realm: "{{ ephemeral_realm }}" + alias: "Test first broker login" + copyFrom: "first broker login" + authenticationExecutions: + - providerId: "idp-review-profile" + requirement: "REQUIRED" + authenticationConfig: + alias: "Test review profile config" + config: + update.profile.on.first.login: "missing" + +- name: Create conditional OTP auth flow + middleware_automation.keycloak.keycloak_authentication: + realm: "{{ ephemeral_realm }}" + alias: "My conditional browser otp" + description: "browser based authentication with otp" + providerId: "basic-flow" + authenticationExecutions: + - displayName: Cookie + providerId: auth-cookie + requirement: ALTERNATIVE + - displayName: Kerberos + providerId: auth-spnego + requirement: DISABLED + - displayName: Identity Provider Redirector + providerId: identity-provider-redirector + requirement: ALTERNATIVE + - displayName: My browser otp forms + requirement: ALTERNATIVE + - displayName: Username Password Form + flowAlias: My browser otp forms + providerId: auth-username-password-form + requirement: REQUIRED + - displayName: My browser otp Browser - Conditional OTP + flowAlias: My browser otp forms + requirement: REQUIRED + providerId: "auth-conditional-otp-form" + authenticationConfig: + alias: my-conditional-otp-config + config: + defaultOtpOutcome: "force" + noOtpRequiredForHeaderPattern: "{{ keycloak_no_otp_required_pattern_original }}" + state: present + +- name: Update conditional OTP auth flow config + middleware_automation.keycloak.keycloak_authentication: + realm: "{{ ephemeral_realm }}" + alias: "My conditional browser otp" + description: "browser based authentication with otp" + providerId: "basic-flow" + authenticationExecutions: + - displayName: Cookie + providerId: auth-cookie + requirement: ALTERNATIVE + - displayName: Kerberos + providerId: auth-spnego + requirement: DISABLED + - displayName: Identity Provider Redirector + providerId: identity-provider-redirector + requirement: ALTERNATIVE + - displayName: My browser otp forms + requirement: ALTERNATIVE + - displayName: Username Password Form + flowAlias: My browser otp forms + providerId: auth-username-password-form + requirement: REQUIRED + - displayName: My browser otp Browser - Conditional OTP + flowAlias: My browser otp forms + requirement: REQUIRED + providerId: "auth-conditional-otp-form" + authenticationConfig: + alias: my-conditional-otp-config + config: + defaultOtpOutcome: "force" + noOtpRequiredForHeaderPattern: "{{ keycloak_no_otp_required_pattern_modified }}" + state: present + register: result + +- name: Get access token for realm export + ansible.builtin.uri: + url: "{{ auth_keycloak_url }}/realms/{{ auth_realm }}/protocol/openid-connect/token" + method: POST + status_code: 200 + body_format: form-urlencoded + body: + grant_type: "password" + client_id: "admin-cli" + username: "{{ auth_username }}" + password: "{{ auth_password }}" + register: token_response + +- name: Extract access token + ansible.builtin.set_fact: + access_token: "{{ token_response.json.access_token }}" + +- name: Export ephemeral realm + ansible.builtin.uri: + url: "{{ auth_keycloak_url }}/admin/realms/{{ ephemeral_realm }}/partial-export?exportClients=false&exportGroupsAndRoles=false" + method: POST + headers: + Accept: application/json + User-agent: Ansible + Authorization: "Bearer {{ access_token }}" + body_format: form-urlencoded + body: {} + register: exported_realm + no_log: true + +- name: Assert my-conditional-otp-config exists only once + ansible.builtin.assert: + that: + - exported_realm.json.authenticatorConfig | selectattr('alias', 'equalto', 'my-conditional-otp-config') | list | length == 1 + +- name: Delete conditional OTP auth flow + middleware_automation.keycloak.keycloak_authentication: + realm: "{{ ephemeral_realm }}" + alias: "My conditional browser otp" + state: absent + register: result diff --git a/molecule/keycloak_modules/keycloak_authz_authorization_scope/verify.yml b/molecule/keycloak_modules/keycloak_authz_authorization_scope/verify.yml new file mode 100644 index 0000000..a08757c --- /dev/null +++ b/molecule/keycloak_modules/keycloak_authz_authorization_scope/verify.yml @@ -0,0 +1,164 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_authz_authorization_scope +# Tests full CRUD lifecycle with check_mode, diff, and idempotency. + +- name: Create authorization scope (check mode) + middleware_automation.keycloak.keycloak_authz_authorization_scope: + state: present + name: "file:delete" + display_name: "File delete" + icon_uri: "http://localhost/icon.png" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + check_mode: true + diff: true + register: result + +- name: Assert scope not created in check mode + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + - result.msg == 'Authorization scope would be created' + - result.diff.before == {} + - result.diff.after.name == 'file:delete' + - result.diff.after.displayName == 'File delete' + - result.diff.after.iconUri == 'http://localhost/icon.png' + +- name: Create authorization scope + middleware_automation.keycloak.keycloak_authz_authorization_scope: + state: present + name: "file:delete" + display_name: "File delete" + icon_uri: "http://localhost/icon.png" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert scope created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "file:delete" + - result.end_state.iconUri == "http://localhost/icon.png" + - result.end_state.displayName == "File delete" + +- name: Create authorization scope (idempotency) + middleware_automation.keycloak.keycloak_authz_authorization_scope: + state: present + name: "file:delete" + display_name: "File delete" + icon_uri: "http://localhost/icon.png" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert scope unchanged + ansible.builtin.assert: + that: + - result is not changed + - result.end_state != {} + - result.end_state.name == "file:delete" + - result.end_state.iconUri == "http://localhost/icon.png" + - result.end_state.displayName == "File delete" + +- name: Update scope - remove optional params (check mode) + middleware_automation.keycloak.keycloak_authz_authorization_scope: + state: present + name: "file:delete" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + diff: true + check_mode: true + register: result + +- name: Assert scope not updated in check mode + ansible.builtin.assert: + that: + - result is changed + - result.msg == 'Authorization scope would be updated' + - result.diff.before.displayName == 'File delete' + - result.diff.before.iconUri == 'http://localhost/icon.png' + - result.diff.after.displayName == '' + - result.diff.after.iconUri == '' + +- name: Update scope - remove optional params + middleware_automation.keycloak.keycloak_authz_authorization_scope: + state: present + name: "file:delete" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert optional params removed + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "file:delete" + - result.end_state.iconUri == "" + - result.end_state.displayName == "" + +- name: Update scope - idempotency after removal + middleware_automation.keycloak.keycloak_authz_authorization_scope: + state: present + name: "file:delete" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert scope unchanged after update + ansible.builtin.assert: + that: + - result is not changed + - result.end_state != {} + - result.end_state.name == "file:delete" + - result.end_state.iconUri == "" + - result.end_state.displayName == "" + +- name: Remove scope (check mode) + middleware_automation.keycloak.keycloak_authz_authorization_scope: + state: absent + name: "file:delete" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + diff: true + check_mode: true + register: result + +- name: Assert scope not removed in check mode + ansible.builtin.assert: + that: + - result is changed + - result.msg == 'Authorization scope would be removed' + - result.diff.before.name == 'file:delete' + - result.diff.after == {} + +- name: Remove scope + middleware_automation.keycloak.keycloak_authz_authorization_scope: + state: absent + name: "file:delete" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert scope removed + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Remove scope (idempotency) + middleware_automation.keycloak.keycloak_authz_authorization_scope: + state: absent + name: "file:delete" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert scope already absent + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} diff --git a/molecule/keycloak_modules/keycloak_authz_permission/verify.yml b/molecule/keycloak_modules/keycloak_authz_permission/verify.yml new file mode 100644 index 0000000..4891fd3 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_authz_permission/verify.yml @@ -0,0 +1,489 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_authz_permission +# Tests error paths, scope permission CRUD, resource permission CRUD, permission_info queries. + +# KC 26.x no longer auto-creates "Default Policy" and "Default Resource" +# when authorization services are enabled via API. + +- name: Obtain access token for policy setup + ansible.builtin.uri: + url: "{{ auth_keycloak_url }}/realms/{{ auth_realm }}/protocol/openid-connect/token" + method: POST + body_format: form-urlencoded + body: + grant_type: password + client_id: admin-cli + username: "{{ auth_username }}" + password: "{{ auth_password }}" + validate_certs: false + register: authz_perm_token + +- name: Look up client UUID + ansible.builtin.uri: + url: "{{ auth_keycloak_url }}/admin/realms/{{ target_realm }}/clients?clientId={{ client }}" + headers: + Authorization: "Bearer {{ authz_perm_token.json.access_token }}" + validate_certs: false + register: authz_perm_client + +- name: Ensure Default Policy exists (role-based positive policy) + ansible.builtin.uri: + url: "{{ auth_keycloak_url }}/admin/realms/{{ target_realm }}/clients/{{ authz_perm_client.json[0].id }}/authz/resource-server/policy/role" + method: POST + headers: + Authorization: "Bearer {{ authz_perm_token.json.access_token }}" + Content-Type: application/json + body_format: json + body: + name: "Default Policy" + description: "A default policy" + logic: POSITIVE + roles: [] + status_code: [201, 409] + validate_certs: false + +- name: Ensure Default Resource exists + ansible.builtin.uri: + url: "{{ auth_keycloak_url }}/admin/realms/{{ target_realm }}/clients/{{ authz_perm_client.json[0].id }}/authz/resource-server/resource" + method: POST + headers: + Authorization: "Bearer {{ authz_perm_token.json.access_token }}" + Content-Type: application/json + body_format: json + body: + name: "Default Resource" + type: "urn:molecule-client:resources:default" + uris: + - "/*" + status_code: [201, 409] + validate_certs: false + +- name: Create file:create authorization scope + middleware_automation.keycloak.keycloak_authz_authorization_scope: + state: present + name: "file:create" + display_name: "File create" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + +- name: Create file:delete authorization scope + middleware_automation.keycloak.keycloak_authz_authorization_scope: + state: present + name: "file:delete" + display_name: "File delete" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + +# --- Error paths --- + +- name: Create permission without type (test for failure) + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ScopePermission" + description: "Scope permission" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + failed_when: result.msg.find('missing required arguments') == -1 + +- name: Create scope permission without scopes (test for failure) + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ScopePermission" + description: "Scope permission" + permission_type: scope + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + failed_when: result.msg.find('Scopes need to defined when permission type is set to scope!') == -1 + +- name: Create scope permission with multiple resources (test for failure) + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ScopePermission" + description: "Scope permission" + resources: + - "Default Resource" + - "Other Resource" + permission_type: scope + scopes: + - "file:delete" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + failed_when: result.msg.find('Only one resource can be defined for a scope permission!') == -1 + +- name: Create scope permission with invalid policy name (test for failure) + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ScopePermission" + description: "Scope permission" + permission_type: scope + scopes: + - "file:delete" + policies: + - "Missing Policy" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + failed_when: result.msg.find('Unable to find authorization policy with name') == -1 + +# --- Scope permission CRUD --- + +- name: Create scope permission + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ScopePermission" + description: "Scope permission" + permission_type: scope + scopes: + - "file:delete" + policies: + - "Default Policy" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert scope permission was created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "ScopePermission" + - result.end_state.description == "Scope permission" + - result.end_state.type == "scope" + - result.end_state.resources == [] + - result.end_state.policies | length == 1 + - result.end_state.scopes | length == 1 + +- name: Query scope permission state + middleware_automation.keycloak.keycloak_authz_permission_info: + name: "ScopePermission" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert queried state matches + ansible.builtin.assert: + that: + - result.queried_state.name == "ScopePermission" + - result.queried_state.description == "Scope permission" + +- name: Create scope permission (idempotency) + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ScopePermission" + description: "Scope permission" + permission_type: scope + scopes: + - "file:delete" + policies: + - "Default Policy" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert scope permission unchanged + ansible.builtin.assert: + that: + - result.end_state != {} + - result.end_state.name == "ScopePermission" + - result.end_state.description == "Scope permission" + - result.end_state.type == "scope" + - result.end_state.resources == [] + - result.end_state.policies | length == 1 + - result.end_state.scopes | length == 1 + +- name: Query scope permission state after idempotency + middleware_automation.keycloak.keycloak_authz_permission_info: + name: "ScopePermission" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert queried state matches after idempotency + ansible.builtin.assert: + that: + - result.queried_state.name == "ScopePermission" + - result.queried_state.description == "Scope permission" + +- name: Update scope permission + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ScopePermission" + description: "Scope permission changed" + permission_type: scope + decision_strategy: 'AFFIRMATIVE' + scopes: + - "file:create" + - "file:delete" + policies: [] + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert scope permission updated + ansible.builtin.assert: + that: + - result.changed == True + - result.end_state != {} + - result.end_state.scopes | length == 2 + - result.end_state.policies == [] + - result.end_state.resources == [] + - result.end_state.name == "ScopePermission" + - result.end_state.description == "Scope permission changed" + +- name: Query updated scope permission state + middleware_automation.keycloak.keycloak_authz_permission_info: + name: "ScopePermission" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert queried state matches after update + ansible.builtin.assert: + that: + - result.queried_state.name == "ScopePermission" + - result.queried_state.description == "Scope permission changed" + +- name: Update scope permission (idempotency) + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ScopePermission" + description: "Scope permission changed" + permission_type: scope + decision_strategy: 'AFFIRMATIVE' + scopes: + - "file:create" + - "file:delete" + policies: [] + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert scope permission update idempotent + ansible.builtin.assert: + that: + - result.changed == True + - result.end_state != {} + - result.end_state.scopes | length == 2 + - result.end_state.policies == [] + - result.end_state.resources == [] + - result.end_state.name == "ScopePermission" + - result.end_state.description == "Scope permission changed" + +- name: Query scope permission state after update idempotency + middleware_automation.keycloak.keycloak_authz_permission_info: + name: "ScopePermission" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert queried state matches after update idempotency + ansible.builtin.assert: + that: + - result.queried_state.name == "ScopePermission" + - result.queried_state.description == "Scope permission changed" + +- name: Remove scope permission + middleware_automation.keycloak.keycloak_authz_permission: + state: absent + name: "ScopePermission" + permission_type: scope + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert scope permission removed + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Remove scope permission (idempotency) + middleware_automation.keycloak.keycloak_authz_permission: + state: absent + name: "ScopePermission" + permission_type: scope + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert scope permission already absent + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} + +# --- Resource permission error paths --- + +- name: Create resource permission without resources (test for failure) + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ResourcePermission" + description: "Resource permission" + permission_type: resource + policies: + - "Default Policy" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + failed_when: result.msg.find('A resource need to defined when permission type is set to resource!') == -1 + +- name: Create resource permission with scopes (test for failure) + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ResourcePermission" + description: "Resource permission" + permission_type: resource + resources: + - "Default Resource" + policies: + - "Default Policy" + scopes: + - "file:delete" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + failed_when: result.msg.find('Scopes cannot be defined when permission type is set to resource!') == -1 + +# --- Resource permission CRUD --- + +- name: Create resource permission + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ResourcePermission" + description: "Resource permission" + resources: + - "Default Resource" + permission_type: resource + policies: + - "Default Policy" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert resource permission was created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.policies | length == 1 + - result.end_state.resources | length == 1 + - result.end_state.name == "ResourcePermission" + - result.end_state.description == "Resource permission" + +- name: Query resource permission state + middleware_automation.keycloak.keycloak_authz_permission_info: + name: "ResourcePermission" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert queried resource state matches + ansible.builtin.assert: + that: + - result.queried_state.name == "ResourcePermission" + - result.queried_state.description == "Resource permission" + +- name: Create resource permission (idempotency) + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ResourcePermission" + description: "Resource permission" + resources: + - "Default Resource" + permission_type: resource + policies: + - "Default Policy" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert resource permission unchanged + ansible.builtin.assert: + that: + - result.end_state != {} + - result.end_state.policies | length == 1 + - result.end_state.resources | length == 1 + - result.end_state.name == "ResourcePermission" + - result.end_state.description == "Resource permission" + +- name: Query resource permission state after idempotency + middleware_automation.keycloak.keycloak_authz_permission_info: + name: "ResourcePermission" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert queried resource state matches after idempotency + ansible.builtin.assert: + that: + - result.queried_state.name == "ResourcePermission" + - result.queried_state.description == "Resource permission" + +- name: Update resource permission + middleware_automation.keycloak.keycloak_authz_permission: + state: present + name: "ResourcePermission" + description: "Resource permission changed" + resources: + - "Default Resource" + permission_type: resource + policies: [] + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert resource permission updated + ansible.builtin.assert: + that: + - result.changed == True + - result.end_state != {} + - result.end_state.policies == [] + - result.end_state.resources | length == 1 + - result.end_state.name == "ResourcePermission" + - result.end_state.description == "Resource permission changed" + +- name: Query updated resource permission state + middleware_automation.keycloak.keycloak_authz_permission_info: + name: "ResourcePermission" + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert queried resource state matches after update + ansible.builtin.assert: + that: + - result.queried_state.name == "ResourcePermission" + - result.queried_state.description == "Resource permission changed" + +- name: Remove resource permission + middleware_automation.keycloak.keycloak_authz_permission: + state: absent + name: "ResourcePermission" + permission_type: resource + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert resource permission removed + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Remove resource permission (idempotency) + middleware_automation.keycloak.keycloak_authz_permission: + state: absent + name: "ResourcePermission" + permission_type: resource + client_id: "{{ client }}" + realm: "{{ target_realm }}" + register: result + +- name: Assert resource permission already absent + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} diff --git a/molecule/keycloak_modules/keycloak_client/vars.yml b/molecule/keycloak_modules/keycloak_client/vars.yml new file mode 100644 index 0000000..83ef623 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_client/vars.yml @@ -0,0 +1,84 @@ +--- +client_id: myclient +client_id_2: mynewclient + +post_logout_redirect_uris: + - "https://example.com/logout-callback" + - "https://example.com/signout" +backchannel_logout_url: "https://example.com/backchannel-logout" + +redirect_uris1: + - "http://example.c.com/" + - "http://example.b.com/" + - "http://example.a.com/" + +client_attributes1: {"backchannel.logout.session.required": true, "backchannel.logout.revoke.offline.tokens": false, "oauth2.device.authorization.grant.enabled": true, "client.secret.creation.time": 0} + +client_attributes2: {"backchannel.logout.session.required": false, "oauth2.device.authorization.grant.enabled": false, "client.secret.creation.time": 0} + +protocol_mappers1: + - name: 'email' + protocol: 'openid-connect' + protocolMapper: 'oidc-usermodel-property-mapper' + config: + "claim.name": "email" + "user.attribute": "email" + "jsonType.label": "String" + "id.token.claim": true + "access.token.claim": true + "userinfo.token.claim": true + + - name: 'email_verified' + protocol: 'openid-connect' + protocolMapper: 'oidc-usermodel-property-mapper' + config: + "claim.name": "email_verified" + "user.attribute": "emailVerified" + "jsonType.label": "boolean" + "id.token.claim": true + "access.token.claim": true + "userinfo.token.claim": true + + - name: 'family_name' + protocol: 'openid-connect' + protocolMapper: 'oidc-usermodel-property-mapper' + config: + "claim.name": "family_name" + "user.attribute": "lastName" + "jsonType.label": "String" + "id.token.claim": "true" + "access.token.claim": "true" + "userinfo.token.claim": "true" + +protocol_mappers2_unordered: + - "{{ protocol_mappers1[2] }}" + - "{{ protocol_mappers1[1] }}" + - "{{ protocol_mappers1[0] }}" + +protocol_mappers3_modifed: + - "{{ protocol_mappers1[2] }}" + - name: address + protocol: openid-connect + protocolMapper: oidc-address-mapper + consentRequired: false + config: + user.attribute.formatted: formatted + user.attribute.country: country + introspection.token.claim: 'true' + user.attribute.postal_code: postal_code + userinfo.token.claim: 'true' + user.attribute.street: street + id.token.claim: 'true' + user.attribute.region: region + access.token.claim: 'true' + user.attribute.locality: locality + - name: 'email' + protocol: 'openid-connect' + protocolMapper: 'oidc-usermodel-property-mapper' + config: + "claim.name": "email" + "user.attribute": "email" + "jsonType.label": "String" + "id.token.claim": true + "access.token.claim": false + "userinfo.token.claim": true diff --git a/molecule/keycloak_modules/keycloak_client/verify.yml b/molecule/keycloak_modules/keycloak_client/verify.yml new file mode 100644 index 0000000..ce1227e --- /dev/null +++ b/molecule/keycloak_modules/keycloak_client/verify.yml @@ -0,0 +1,409 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_client +# Tests protocol_mapper CRUD, flow binding overrides, client_scopes_behavior, +# attribute updates, and post-logout redirect URIs / backchannel logout URL. + +- name: Load client test variables + ansible.builtin.include_vars: + file: vars.yml + +# --- Protocol mapper create, idempotency, and modification --- + +- name: Desire client + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + state: present + redirect_uris: "{{ redirect_uris1 }}" + attributes: "{{ client_attributes1 }}" + protocol_mappers: "{{ protocol_mappers1 }}" + register: desire_client_not_present + +- name: Desire client again with same props + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + state: present + redirect_uris: "{{ redirect_uris1 }}" + attributes: "{{ client_attributes1 }}" + protocol_mappers: "{{ protocol_mappers1 }}" + register: desire_client_when_present_and_same + +- name: Check client again with same props + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + state: present + redirect_uris: "{{ redirect_uris1 }}" + attributes: "{{ client_attributes1 }}" + protocol_mappers: "{{ protocol_mappers2_unordered }}" + authorization_services_enabled: false + check_mode: true + register: check_client_when_present_and_same + +- name: Assert changes not detected in last two tasks (desire when same, and check) + ansible.builtin.assert: + that: + - desire_client_when_present_and_same is not changed + - check_client_when_present_and_same is not changed + +- name: Check client again with changed props + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + state: present + redirect_uris: "{{ redirect_uris1 }}" + attributes: "{{ client_attributes1 }}" + protocol_mappers: "{{ protocol_mappers1 }}" + authorization_services_enabled: false + service_accounts_enabled: false + check_mode: true + register: check_client_when_present_and_changed + +- name: Assert changes detected in last tasks + ansible.builtin.assert: + that: + - check_client_when_present_and_changed is changed + +- name: Check client with modified protocol_mappers idempotence + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + state: present + redirect_uris: "{{ redirect_uris1 }}" + attributes: "{{ client_attributes1 }}" + protocol_mappers: "{{ protocol_mappers3_modifed }}" + authorization_services_enabled: false + service_accounts_enabled: true + register: check_client_protocol_mappers_idempotence + +- name: Assert idempotence changes to protocol_mappers + ansible.builtin.assert: + that: + - check_client_protocol_mappers_idempotence is changed + - end_state.protocolMappers | length == 3 + - end_state.protocolMappers | selectattr('name', 'equalto', 'email_verified') | list | length == 0 + - end_state.protocolMappers | selectattr('name', 'equalto', 'address') | list | length == 1 + - end_state.protocolMappers | selectattr('name', 'equalto', 'email') | list | length == 1 + - end_state.protocolMappers | selectattr('name', 'equalto', 'family_name') | list | length == 1 + - email.config is defined + - email.config['access.token.claim'] == "false" + vars: + end_state: "{{ check_client_protocol_mappers_idempotence.end_state }}" + email: "{{ end_state.protocolMappers | selectattr('name', 'equalto', 'email') | first | default({}) }}" + +# --- Flow binding overrides --- + +- name: Desire client with flow binding overrides + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + state: present + redirect_uris: "{{ redirect_uris1 }}" + attributes: "{{ client_attributes1 }}" + protocol_mappers: "{{ protocol_mappers1 }}" + authentication_flow_binding_overrides: + browser_name: browser + direct_grant_name: direct grant + register: desire_client_with_flow_binding_overrides + +- name: Assert flows are set + ansible.builtin.assert: + that: + - desire_client_with_flow_binding_overrides is changed + - "'authenticationFlowBindingOverrides' in desire_client_with_flow_binding_overrides.end_state" + - desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides.browser | length > 0 + - desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides.direct_grant | length > 0 + +- name: Backup flow UUIDs + ansible.builtin.set_fact: + flow_browser_uuid: "{{ desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides.browser }}" + flow_direct_grant_uuid: "{{ desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides.direct_grant }}" + +- name: Desire client with flow binding overrides remove direct_grant_name + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + state: present + redirect_uris: "{{ redirect_uris1 }}" + attributes: "{{ client_attributes1 }}" + protocol_mappers: "{{ protocol_mappers1 }}" + authentication_flow_binding_overrides: + browser_name: browser + register: desire_client_with_flow_binding_overrides + +- name: Assert flows are updated + ansible.builtin.assert: + that: + - desire_client_with_flow_binding_overrides is changed + - "'authenticationFlowBindingOverrides' in desire_client_with_flow_binding_overrides.end_state" + - desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides.browser | length > 0 + - "'direct_grant' not in desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides" + +- name: Desire client with flow binding overrides remove browser add direct_grant + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + state: present + redirect_uris: "{{ redirect_uris1 }}" + attributes: "{{ client_attributes1 }}" + protocol_mappers: "{{ protocol_mappers1 }}" + authentication_flow_binding_overrides: + direct_grant_name: direct grant + register: desire_client_with_flow_binding_overrides + +- name: Assert flows are updated + ansible.builtin.assert: + that: + - desire_client_with_flow_binding_overrides is changed + - "'authenticationFlowBindingOverrides' in desire_client_with_flow_binding_overrides.end_state" + - "'browser' not in desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides" + - desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides.direct_grant | length > 0 + +- name: Desire client with flow binding overrides with UUIDs + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + state: present + redirect_uris: "{{ redirect_uris1 }}" + attributes: "{{ client_attributes1 }}" + protocol_mappers: "{{ protocol_mappers1 }}" + authentication_flow_binding_overrides: + browser: "{{ flow_browser_uuid }}" + direct_grant: "{{ flow_direct_grant_uuid }}" + register: desire_client_with_flow_binding_overrides + +- name: Assert flows are updated + ansible.builtin.assert: + that: + - desire_client_with_flow_binding_overrides is changed + - "'authenticationFlowBindingOverrides' in desire_client_with_flow_binding_overrides.end_state" + - desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides.browser == flow_browser_uuid + - desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides.direct_grant == flow_direct_grant_uuid + +- name: Unset flow binding overrides + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + state: present + redirect_uris: "{{ redirect_uris1 }}" + attributes: "{{ client_attributes1 }}" + protocol_mappers: "{{ protocol_mappers1 }}" + authentication_flow_binding_overrides: + browser: "{{ None }}" + direct_grant: null + register: desire_client_with_flow_binding_overrides + +- name: Assert flows are removed + ansible.builtin.assert: + that: + - desire_client_with_flow_binding_overrides is changed + - "'authenticationFlowBindingOverrides' in desire_client_with_flow_binding_overrides.end_state" + - "'browser' not in desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides" + - "'direct_grant' not in desire_client_with_flow_binding_overrides.end_state.authenticationFlowBindingOverrides" + +# --- Client scopes behavior --- + +- name: Create a scope1 client scope + middleware_automation.keycloak.keycloak_client_scope: + realm: "{{ ephemeral_realm }}" + name: scope1 + description: "test 1" + protocol: openid-connect + +- name: Create a scope2 client scope + middleware_automation.keycloak.keycloak_client_scope: + realm: "{{ ephemeral_realm }}" + name: scope2 + description: "test 2" + protocol: openid-connect + +- name: Create a scope3 client scope + middleware_automation.keycloak.keycloak_client_scope: + realm: "{{ ephemeral_realm }}" + name: scope3 + description: "test 3" + protocol: openid-connect + +- name: Create Keycloak client with default_client_scopes (idempotent behavior) + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_scopes_behavior: idempotent + default_client_scopes: ['scope1'] + optional_client_scopes: ['scope2'] + client_id: testSD-bug + state: present + register: desire_client_with_default_client_scopes + +- name: Assert default_client_scopes and optional_client_scopes are set correctly + ansible.builtin.assert: + that: + - desire_client_with_default_client_scopes is changed + - '"scope1" in end_state.defaultClientScopes' + - '"scope2" in end_state.optionalClientScopes' + - end_state.defaultClientScopes | length == 1 + - end_state.optionalClientScopes | length == 1 + vars: + end_state: "{{ desire_client_with_default_client_scopes.end_state }}" + +- name: Update Keycloak client with new scopes (ignore behavior, check mode) + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + default_client_scopes: ['scope3'] + optional_client_scopes: ['scope3'] + client_id: testSD-bug + state: present + check_mode: true + register: desire_client_with_default_client_scopes + +- name: Assert client scopes remain unchanged with ignore behavior + ansible.builtin.assert: + that: + - desire_client_with_default_client_scopes is not changed + - end_state.defaultClientScopes | length == 1 + - end_state.optionalClientScopes | length == 1 + - '"scope1" in end_state.defaultClientScopes' + - '"scope2" in end_state.optionalClientScopes' + vars: + end_state: "{{ desire_client_with_default_client_scopes.end_state }}" + +- name: Update Keycloak client with conflicting scopes (patch behavior, should fail) + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_scopes_behavior: patch + default_client_scopes: ['scope3'] + optional_client_scopes: ['scope1', 'scope2', 'scope3'] + client_id: testSD-bug + state: present + ignore_errors: true + register: desire_client_with_default_client_scopes + +- name: Assert patch behavior fails when scope is both default and optional + ansible.builtin.assert: + that: + - desire_client_with_default_client_scopes is failed + - "'scope3' in desire_client_with_default_client_scopes.msg" + +- name: Update Keycloak client with new scopes (patch behavior) + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_scopes_behavior: patch + default_client_scopes: ['scope1', 'scope3'] + optional_client_scopes: [] + client_id: testSD-bug + state: present + register: desire_client_with_default_client_scopes + +- name: Assert client scopes are patched correctly + ansible.builtin.assert: + that: + - desire_client_with_default_client_scopes is changed + - end_state.defaultClientScopes | length == 2 + - end_state.optionalClientScopes | length == 1 + - '"scope1" in end_state.defaultClientScopes' + - '"scope3" in end_state.defaultClientScopes' + - '"scope2" in end_state.optionalClientScopes' + vars: + end_state: "{{ desire_client_with_default_client_scopes.end_state }}" + +- name: Update Keycloak client with empty default_client_scopes (idempotent behavior) + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_scopes_behavior: idempotent + default_client_scopes: [] + optional_client_scopes: ['scope3'] + client_id: testSD-bug + state: present + register: desire_client_with_default_client_scopes + +- name: Assert idempotent behavior with empty default_client_scopes + ansible.builtin.assert: + that: + - desire_client_with_default_client_scopes is changed + - end_state.defaultClientScopes | length == 0 + - end_state.optionalClientScopes | length == 1 + - '"scope3" in end_state.optionalClientScopes' + vars: + end_state: "{{ desire_client_with_default_client_scopes.end_state }}" + +# --- Attribute updates --- + +- name: Create client with initial attributes + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id_2 }}" + state: present + attributes: "{{ client_attributes1 }}" + register: check_client_when_present_and_attributes_modified + +- name: Update client attributes + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id_2 }}" + state: present + attributes: "{{ client_attributes2 }}" + register: check_client_when_present_and_attributes_modified + +- name: Assert client attributes are updated + ansible.builtin.assert: + that: + - check_client_when_present_and_attributes_modified is changed + - end_state.attributes["backchannel.logout.revoke.offline.tokens"] == 'false' + - end_state.attributes["backchannel.logout.session.required"] == 'false' + - end_state.attributes["oauth2.device.authorization.grant.enabled"] == 'false' + vars: + end_state: "{{ check_client_when_present_and_attributes_modified.end_state }}" + +# --- Post-logout redirect URIs and backchannel logout URL --- + +- name: Create client with post logout redirect URIs and backchannel logout URL + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: logout-test-client + valid_post_logout_redirect_uris: "{{ post_logout_redirect_uris }}" + backchannel_logout_url: "{{ backchannel_logout_url }}" + state: present + register: result_create_logout_client + +- name: Assert logout client is created with correct attributes + ansible.builtin.assert: + that: + - result_create_logout_client is changed + - result_create_logout_client.end_state.attributes["post.logout.redirect.uris"] is defined + - result_create_logout_client.end_state.attributes["backchannel.logout.url"] == backchannel_logout_url + +- name: Re-create client with same logout fields (idempotency) + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: logout-test-client + valid_post_logout_redirect_uris: "{{ post_logout_redirect_uris }}" + backchannel_logout_url: "{{ backchannel_logout_url }}" + state: present + register: result_idempotent_logout_client + +- name: Assert logout client is idempotent + ansible.builtin.assert: + that: + - result_idempotent_logout_client is not changed + +- name: Update client logout fields + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: logout-test-client + valid_post_logout_redirect_uris: + - "https://example.com/new-logout" + backchannel_logout_url: "https://example.com/new-backchannel" + state: present + register: result_update_logout_client + +- name: Assert logout client fields are updated + ansible.builtin.assert: + that: + - result_update_logout_client is changed + - result_update_logout_client.end_state.attributes["backchannel.logout.url"] == "https://example.com/new-backchannel" + +- name: Delete logout test client + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: logout-test-client + state: absent diff --git a/molecule/keycloak_modules/keycloak_client_rolescope/verify.yml b/molecule/keycloak_modules/keycloak_client_rolescope/verify.yml new file mode 100644 index 0000000..87a34b6 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_client_rolescope/verify.yml @@ -0,0 +1,242 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_client_rolescope +# Tests multi-role mapping, remap idempotency, partial removal, error handling, +# duplicate roles, realm role operations, full-scope client rejection, and check_mode. + +# --- Fixtures --- + +- name: Create realm roles for rolescope test + middleware_automation.keycloak.keycloak_role: + name: "{{ item }}" + realm: "{{ ephemeral_realm }}" + state: present + loop: + - realm-role-admin + - realm-role-user + +- name: Create private client (full_scope_allowed) + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: backend-client-private + state: present + redirect_uris: + - "https://my-backend-api.c.org/" + full_scope_allowed: true + attributes: {"backchannel.logout.session.required": true, "backchannel.logout.revoke.offline.tokens": false, "client.secret.creation.time": 0} + public_client: false + +- name: Create client roles on private client + middleware_automation.keycloak.keycloak_role: + name: "{{ item }}" + realm: "{{ ephemeral_realm }}" + client_id: backend-client-private + state: present + loop: + - client-role-admin + - client-role-user + +- name: Create public client (full_scope_allowed false) + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: frontend-client-public + redirect_uris: + - "https://my-onepage-app-frontend.c.org/" + attributes: {"backchannel.logout.session.required": true, "backchannel.logout.revoke.offline.tokens": false, "client.secret.creation.time": 0} + full_scope_allowed: false + public_client: true + +# --- Client role scope mapping --- + +- name: Map two client roles to public client + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: frontend-client-public + role_owner_client_id: backend-client-private + role_names: + - client-role-admin + - client-role-user + register: result + +- name: Assert both client roles mapped + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 2 + +- name: Remap single role (additive idempotency) + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: frontend-client-public + role_owner_client_id: backend-client-private + role_names: + - client-role-user + register: result + +- name: Assert no change - both still mapped + ansible.builtin.assert: + that: + - result is not changed + - result.end_state | length == 2 + +- name: Remove admin role from public client scope + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: frontend-client-public + role_owner_client_id: backend-client-private + role_names: + - client-role-admin + state: absent + register: result + +- name: Assert admin removed, user remains + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 1 + - result.end_state[0].name == "client-role-user" + +# --- Error: missing role --- + +- name: Map non-existent client role (expect failure) + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: frontend-client-public + role_owner_client_id: backend-client-private + role_names: + - client-role-admin + - client-role-missing + ignore_errors: true + register: result + +- name: Assert failure on missing client role + ansible.builtin.assert: + that: + - result is failed + +# --- Duplicate role names --- + +- name: Map duplicate role names + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: frontend-client-public + role_owner_client_id: backend-client-private + role_names: + - client-role-admin + - client-role-admin + register: result + +- name: Assert duplicate handled - both roles mapped + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 2 + +# --- Error: full-scope client --- + +- name: Map realm role to full-scope private client (expect failure) + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: backend-client-private + role_names: + - realm-role-admin + ignore_errors: true + register: result + +- name: Assert failure on full-scope client + ansible.builtin.assert: + that: + - result is failed + +# --- Realm role scope mapping --- + +- name: Map one realm role to public client + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: frontend-client-public + role_names: + - realm-role-admin + register: result + +- name: Assert realm role mapped + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 1 + +- name: Map two realm roles to public client + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: frontend-client-public + role_names: + - realm-role-admin + - realm-role-user + register: result + +- name: Assert both realm roles mapped + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 2 + +- name: Unmap all realm roles from public client + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: frontend-client-public + role_names: + - realm-role-admin + - realm-role-user + state: absent + register: result + +- name: Assert all realm roles unmapped + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 0 + +# --- Error: missing realm role --- + +- name: Map non-existent realm role (expect failure) + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: frontend-client-public + role_names: + - client-role-missing + ignore_errors: true + register: result + +- name: Assert failure on missing realm role + ansible.builtin.assert: + that: + - result is failed + +# --- Check mode --- + +- name: Check-mode map realm roles to public client + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: frontend-client-public + role_names: + - realm-role-admin + - realm-role-user + check_mode: true + register: result + +- name: Assert check-mode reports changed + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 2 + +- name: Verify check-mode did not actually apply changes + middleware_automation.keycloak.keycloak_client_rolescope: + realm: "{{ ephemeral_realm }}" + target_client_id: frontend-client-public + role_names: [] + register: result + +- name: Assert no roles present after check-mode + ansible.builtin.assert: + that: + - result is not changed + - result.end_state | length == 0 diff --git a/molecule/keycloak_modules/keycloak_client_scope_rolemappings/verify.yml b/molecule/keycloak_modules/keycloak_client_scope_rolemappings/verify.yml new file mode 100644 index 0000000..d64f25c --- /dev/null +++ b/molecule/keycloak_modules/keycloak_client_scope_rolemappings/verify.yml @@ -0,0 +1,247 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_client_scope_rolemappings +# Tests multi-role mapping, error paths, check_mode, partial removal, and full-scope rejection. + +# --- Fixtures --- + +- name: Create client for scope rolemapping tests + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: backend-client + state: present + public_client: true + full_scope_allowed: false + +- name: Create full-scope client for rejection test + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: full-scope-client + state: present + public_client: true + full_scope_allowed: true + +- name: Create realm roles + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: "{{ item }}" + loop: + - realm-role-admin + - realm-role-user + +- name: Create client roles + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + client_id: backend-client + name: "{{ item }}" + loop: + - client-role-admin + - client-role-user + +- name: Create client roles in full-scope client + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + client_id: full-scope-client + name: "{{ item }}" + loop: + - client-role-admin + - client-role-user + +- name: Create client scope + middleware_automation.keycloak.keycloak_client_scope: + realm: "{{ ephemeral_realm }}" + name: client-scope + description: "" + protocol: openid-connect + state: present + +# --- Client role mapping tests --- + +- name: Map two client roles to scope + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_id: backend-client + client_scope_id: client-scope + role_names: + - client-role-admin + - client-role-user + register: result + +- name: Assert both client roles mapped + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 2 + +- name: Remap one existing client role (idempotency - additive) + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_id: backend-client + client_scope_id: client-scope + role_names: + - client-role-user + register: result + +- name: Assert no change and both still mapped + ansible.builtin.assert: + that: + - result is not changed + - result.end_state | length == 2 + +- name: Remove admin client role from scope + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_id: backend-client + client_scope_id: client-scope + role_names: + - client-role-admin + state: absent + register: result + +- name: Assert admin role removed and user role remains + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 1 + - result.end_state[0].name == "client-role-user" + +- name: Map non-existent client role + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_id: backend-client + client_scope_id: client-scope + role_names: + - client-role-admin + - client-role-missing + ignore_errors: true + register: result + +- name: Assert failed for missing client role + ansible.builtin.assert: + that: + - result is failed + - "result.msg == \"Failed to retrieve role '\" ~ ephemeral_realm ~ \".backend-client.client-role-missing'\"" + +- name: Map duplicate client roles + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_id: backend-client + client_scope_id: client-scope + role_names: + - client-role-admin + - client-role-admin + register: result + +- name: Assert duplicate handled and both roles present + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 2 + +- name: Map role to full-scope client (should fail) + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_scope_id: client-scope + client_id: full-scope-client + role_names: + - client-role-admin + ignore_errors: true + register: result + +- name: Assert full-scope client rejected + ansible.builtin.assert: + that: + - result is failed + - "result.msg == \"FullScopeAllowed is active for Client '\" ~ ephemeral_realm ~ \".full-scope-client'\"" + +# --- Realm role mapping tests --- + +- name: Map one realm role to scope + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_scope_id: client-scope + role_names: + - realm-role-admin + register: result + +- name: Assert realm role mapped + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 1 + +- name: Map two realm roles + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_scope_id: client-scope + role_names: + - realm-role-admin + - realm-role-user + register: result + +- name: Assert both realm roles mapped + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 2 + +- name: Unmap all realm roles + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_scope_id: client-scope + role_names: + - realm-role-admin + - realm-role-user + state: absent + register: result + +- name: Assert all realm roles unmapped + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 0 + +- name: Map non-existent realm role + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_scope_id: client-scope + role_names: + - client-role-missing + ignore_errors: true + register: result + +- name: Assert failed for missing realm role + ansible.builtin.assert: + that: + - result is failed + - "result.msg == \"Failed to retrieve role '\" ~ ephemeral_realm ~ \".client-role-missing'\"" + +# --- Check-mode test --- + +- name: Map realm roles in check mode + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_scope_id: client-scope + role_names: + - realm-role-admin + - realm-role-user + check_mode: true + register: result + +- name: Assert check mode reports change + ansible.builtin.assert: + that: + - result is changed + - result.end_state | length == 2 + +- name: Verify check mode did not persist changes + middleware_automation.keycloak.keycloak_client_scope_rolemappings: + realm: "{{ ephemeral_realm }}" + client_scope_id: client-scope + role_names: [] + register: result + +- name: Assert no roles actually mapped after check mode + ansible.builtin.assert: + that: + - result is not changed + - result.end_state | length == 0 diff --git a/molecule/keycloak_modules/keycloak_client_scope_type/verify.yml b/molecule/keycloak_modules/keycloak_client_scope_type/verify.yml new file mode 100644 index 0000000..13a1749 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_client_scope_type/verify.yml @@ -0,0 +1,115 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_client_scope_type +# Tests full realm-level and client-level scope type management with idempotency. + +- name: Create client for scope type tests + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: clientscope-type-client + state: present + enabled: true + +- name: Create scope1 client scope + middleware_automation.keycloak.keycloak_client_scope: + realm: "{{ ephemeral_realm }}" + name: scope1 + description: "test 1" + protocol: openid-connect + +- name: Create scope2 client scope + middleware_automation.keycloak.keycloak_client_scope: + realm: "{{ ephemeral_realm }}" + name: scope2 + description: "test 2" + protocol: openid-connect + +# --- Realm level --- + +- name: Set both scopes as realm defaults + middleware_automation.keycloak.keycloak_client_scope_type: + realm: "{{ ephemeral_realm }}" + default_client_scopes: ['scope1', 'scope2'] + optional_client_scopes: [] + register: result + +- name: Assert realm default scopes are set + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - '"scope1" in result.end_state.default_client_scopes' + - '"scope2" in result.end_state.default_client_scopes' + - result.end_state.default_client_scopes | length == 2 + - result.end_state.optional_client_scopes | length == 0 + +- name: Set same realm defaults (idempotency) + middleware_automation.keycloak.keycloak_client_scope_type: + realm: "{{ ephemeral_realm }}" + default_client_scopes: ['scope1', 'scope2'] + optional_client_scopes: [] + register: result + failed_when: result is changed + +- name: Move scope2 to optional at realm level + middleware_automation.keycloak.keycloak_client_scope_type: + realm: "{{ ephemeral_realm }}" + default_client_scopes: ['scope1'] + optional_client_scopes: ['scope2'] + register: result + +- name: Assert scope2 moved to optional + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - '"scope1" in result.end_state.default_client_scopes' + - '"scope2" in result.end_state.optional_client_scopes' + - result.end_state.default_client_scopes | length == 1 + - result.end_state.optional_client_scopes | length == 1 + +# --- Client level --- + +- name: Set both scopes as client defaults + middleware_automation.keycloak.keycloak_client_scope_type: + realm: "{{ ephemeral_realm }}" + client_id: clientscope-type-client + default_client_scopes: ['scope1', 'scope2'] + optional_client_scopes: [] + register: result + +- name: Assert client default scopes are set + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - '"scope1" in result.end_state.default_client_scopes' + - '"scope2" in result.end_state.default_client_scopes' + - result.end_state.default_client_scopes | length == 2 + - result.end_state.optional_client_scopes | length == 0 + +- name: Set same client defaults (idempotency) + middleware_automation.keycloak.keycloak_client_scope_type: + realm: "{{ ephemeral_realm }}" + client_id: clientscope-type-client + default_client_scopes: ['scope1', 'scope2'] + optional_client_scopes: [] + register: result + failed_when: result is changed + +- name: Move scope2 to optional at client level + middleware_automation.keycloak.keycloak_client_scope_type: + realm: "{{ ephemeral_realm }}" + client_id: clientscope-type-client + default_client_scopes: ['scope1'] + optional_client_scopes: ['scope2'] + register: result + +- name: Assert scope2 moved to optional on client + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - '"scope1" in result.end_state.default_client_scopes' + - '"scope2" in result.end_state.optional_client_scopes' + - result.end_state.default_client_scopes | length == 1 + - result.end_state.optional_client_scopes | length == 1 diff --git a/molecule/keycloak_modules/keycloak_clientsecret_info/verify.yml b/molecule/keycloak_modules/keycloak_clientsecret_info/verify.yml new file mode 100644 index 0000000..1f03897 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_clientsecret_info/verify.yml @@ -0,0 +1,33 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_clientsecret_info +# Tests fetch-by-client_id vs fetch-by-id and value assertions. + +- name: Look up test client to get internal id + middleware_automation.keycloak.keycloak_client: + realm: "{{ target_realm }}" + client_id: "{{ client }}" + state: present + register: client_lookup + +- name: Fetch client secret by client_id + middleware_automation.keycloak.keycloak_clientsecret_info: + realm: "{{ target_realm }}" + client_id: "{{ client }}" + register: fetch_by_client_id_result + +- name: Assert client secret retrieved by client_id + ansible.builtin.assert: + that: + - fetch_by_client_id_result.clientsecret_info.type == "secret" + - fetch_by_client_id_result.clientsecret_info.value | length >= 32 + +- name: Fetch client secret by internal id + middleware_automation.keycloak.keycloak_clientsecret_info: + realm: "{{ target_realm }}" + id: "{{ client_lookup.end_state.id }}" + register: fetch_by_id_result + +- name: Assert both fetch methods return the same secret value + ansible.builtin.assert: + that: + - fetch_by_id_result.clientsecret_info.value == fetch_by_client_id_result.clientsecret_info.value diff --git a/molecule/keycloak_modules/keycloak_clientsecret_regenerate/verify.yml b/molecule/keycloak_modules/keycloak_clientsecret_regenerate/verify.yml new file mode 100644 index 0000000..1e47057 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_clientsecret_regenerate/verify.yml @@ -0,0 +1,34 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_clientsecret_regenerate +# Tests regenerate-by-client_id vs regenerate-by-id and rotation contract. + +- name: Look up test client to get internal id + middleware_automation.keycloak.keycloak_client: + realm: "{{ target_realm }}" + client_id: "{{ client }}" + state: present + register: client_lookup + +- name: Regenerate client secret by client_id + middleware_automation.keycloak.keycloak_clientsecret_regenerate: + realm: "{{ target_realm }}" + client_id: "{{ client }}" + register: regenerate_by_client_id + +- name: Assert regenerated secret is valid + ansible.builtin.assert: + that: + - regenerate_by_client_id.end_state.type == "secret" + - regenerate_by_client_id.end_state.value | length >= 32 + +- name: Regenerate client secret by internal id + middleware_automation.keycloak.keycloak_clientsecret_regenerate: + realm: "{{ target_realm }}" + id: "{{ client_lookup.end_state.id }}" + register: regenerate_by_id + +- name: Assert secret value changed after second regeneration + ansible.builtin.assert: + that: + - regenerate_by_id.end_state.value | length >= 32 + - regenerate_by_id.end_state.value != regenerate_by_client_id.end_state.value diff --git a/molecule/keycloak_modules/keycloak_component_info/verify.yml b/molecule/keycloak_modules/keycloak_component_info/verify.yml new file mode 100644 index 0000000..a6bc13f --- /dev/null +++ b/molecule/keycloak_modules/keycloak_component_info/verify.yml @@ -0,0 +1,218 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_component_info +# Tests querying components by name, provider_type, parent_id, and combined filters. + +- name: Query LDAP federation when absent + middleware_automation.keycloak.keycloak_component_info: + name: myldap + provider_type: "org.keycloak.storage.UserStorageProvider" + realm: "{{ ephemeral_realm }}" + register: result + +- name: Assert LDAP federation is absent + ansible.builtin.assert: + that: + - result is not changed + - result.components | length == 0 + +- name: Create LDAP federation for component_info tests + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ ephemeral_realm }}" + name: myldap + provider_id: ldap + provider_type: org.keycloak.storage.UserStorageProvider + config: + enabled: true + priority: 0 + fullSyncPeriod: -1 + changedSyncPeriod: -1 + cachePolicy: DEFAULT + batchSizeForSync: 1000 + editMode: READ_ONLY + importEnabled: true + syncRegistrations: false + vendor: other + usernameLDAPAttribute: uid + rdnLDAPAttribute: uid + uuidLDAPAttribute: entryUUID + userObjectClasses: "inetOrgPerson, organizationalPerson" + connectionUrl: "ldap://ldap.example.com" + usersDn: "ou=Users,dc=example,dc=com" + authType: simple + bindDn: cn=directory reader + bindCredential: secret + searchScope: 1 + validatePasswordPolicy: false + trustEmail: false + useTruststoreSpi: "ldapsOnly" + connectionPooling: true + pagination: true + allowKerberosAuthentication: false + useKerberosForPasswordAuthentication: false + mappers: + - name: "email" + providerId: "user-attribute-ldap-mapper" + providerType: "org.keycloak.storage.ldap.mappers.LDAPStorageMapper" + config: + ldap.attribute: mail + user.model.attribute: email + is.mandatory.in.ldap: "false" + read.only: "true" + - name: "username" + providerId: "user-attribute-ldap-mapper" + providerType: "org.keycloak.storage.ldap.mappers.LDAPStorageMapper" + config: + ldap.attribute: uid + user.model.attribute: username + is.mandatory.in.ldap: "true" + read.only: "true" + state: present + +- name: Query LDAP federation by name and type + middleware_automation.keycloak.keycloak_component_info: + name: myldap + provider_type: "org.keycloak.storage.UserStorageProvider" + realm: "{{ ephemeral_realm }}" + register: result + +- name: Assert LDAP federation found + ansible.builtin.assert: + that: + - result is not changed + - result.components | length == 1 + - result.components[0].name == "myldap" + +- name: Save LDAP federation id + ansible.builtin.set_fact: + ci_ldap_id: "{{ result.components[0].id }}" + +- name: Query LDAP subcomponents by parent_id + middleware_automation.keycloak.keycloak_component_info: + realm: "{{ ephemeral_realm }}" + parent_id: "{{ ci_ldap_id }}" + register: result + +- name: Assert subcomponents exist + ansible.builtin.assert: + that: + - result is not changed + - result.components | length > 0 + +- name: Query LDAP subcomponents filter by name + middleware_automation.keycloak.keycloak_component_info: + realm: "{{ ephemeral_realm }}" + parent_id: "{{ ci_ldap_id }}" + name: "email" + register: result + +- name: Assert subcomponent with name email exists + ansible.builtin.assert: + that: + - result is not changed + - result.components | length == 1 + - result.components[0].name == "email" + +- name: Query LDAP subcomponents filter by type + middleware_automation.keycloak.keycloak_component_info: + realm: "{{ ephemeral_realm }}" + parent_id: "{{ ci_ldap_id }}" + provider_type: "org.keycloak.storage.ldap.mappers.LDAPStorageMapper" + register: result + +- name: Assert LDAP mapper subcomponents found + ansible.builtin.assert: + that: + - result is not changed + - result.components | length > 0 + - result.components[0].providerType == "org.keycloak.storage.ldap.mappers.LDAPStorageMapper" + +- name: Query key info when absent + middleware_automation.keycloak.keycloak_component_info: + name: testkey + provider_type: "org.keycloak.keys.KeyProvider" + realm: "{{ ephemeral_realm }}" + register: result + +- name: Assert key is missing + ansible.builtin.assert: + that: + - result is not changed + - result.components | length == 0 + +- name: Create AES realm key for component query test + middleware_automation.keycloak.keycloak_realm_key: + name: testkey + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: aes-generated + config: + priority: 150 + enabled: true + active: true + +- name: Query key component by name and type + middleware_automation.keycloak.keycloak_component_info: + name: testkey + provider_type: "org.keycloak.keys.KeyProvider" + realm: "{{ ephemeral_realm }}" + register: result + +- name: Assert key component found + ansible.builtin.assert: + that: + - result is not changed + - result.components | length == 1 + +- name: Query all realm components + middleware_automation.keycloak.keycloak_component_info: + realm: "{{ ephemeral_realm }}" + register: result + +- name: Assert realm has components + ansible.builtin.assert: + that: + - result is not changed + - result.components | length > 0 + +- name: Query all UserStorageProviders in realm + middleware_automation.keycloak.keycloak_component_info: + realm: "{{ ephemeral_realm }}" + provider_type: "org.keycloak.storage.UserStorageProvider" + register: result + +- name: Assert only the LDAP federation is returned + ansible.builtin.assert: + that: + - result is not changed + - result.components | length == 1 + - result.components[0].providerType == "org.keycloak.storage.UserStorageProvider" + - result.components[0].name == "myldap" + +- name: Query component by name only + middleware_automation.keycloak.keycloak_component_info: + realm: "{{ ephemeral_realm }}" + name: testkey + register: result + +- name: Assert key found by name only + ansible.builtin.assert: + that: + - result is not changed + - result.components | length == 1 + - result.components[0].providerType == "org.keycloak.keys.KeyProvider" + - result.components[0].name == "testkey" + +- name: Clean up - remove AES key + middleware_automation.keycloak.keycloak_realm_key: + name: testkey + parent_id: "{{ ephemeral_realm }}" + provider_id: aes-generated + state: absent + +- name: Clean up - remove LDAP federation + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ ephemeral_realm }}" + name: myldap + provider_id: ldap + provider_type: org.keycloak.storage.UserStorageProvider + state: absent diff --git a/molecule/keycloak_modules/keycloak_group/verify.yml b/molecule/keycloak_modules/keycloak_group/verify.yml new file mode 100644 index 0000000..70c0889 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_group/verify.yml @@ -0,0 +1,412 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_group +# Tests group CRUD, custom attributes, subgroups, deep chains, and deletion patterns. + +# --- Group CRUD --- + +- name: Create a group + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: test-group + state: present + register: result + +- name: Assert group was created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "test-group" + - result.end_state.path == "/test-group" + - result.end_state.attributes == {} + - result.end_state.clientRoles == {} + - result.end_state.realmRoles == [] + - result.end_state.subGroups == [] + +- name: Save group id + ansible.builtin.set_fact: + molecule_grp_test_id: "{{ result.end_state.id }}" + +- name: Create group again (idempotency) + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: test-group + state: present + register: result + +- name: Assert group unchanged + ansible.builtin.assert: + that: + - result is not changed + - result.end_state != {} + - result.end_state.name == "test-group" + - result.end_state.path == "/test-group" + - result.end_state.attributes == {} + - result.end_state.clientRoles == {} + - result.end_state.realmRoles == [] + - result.end_state.subGroups == [] + +- name: Rename group by id + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + id: "{{ molecule_grp_test_id }}" + name: new-test-group + state: present + register: result + +- name: Assert group was renamed + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "new-test-group" + - result.end_state.path == "/new-test-group" + - result.end_state.attributes == {} + - result.end_state.clientRoles == {} + - result.end_state.realmRoles == [] + - result.end_state.subGroups == [] + +- name: Delete group by id + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + id: "{{ molecule_grp_test_id }}" + state: absent + register: result + +- name: Assert group was deleted + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Delete group by id again (idempotency) + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + id: "{{ molecule_grp_test_id }}" + state: absent + register: result + +- name: Assert no change on absent group + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} + +# --- Custom attributes --- + +- name: Create group with custom attributes + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: my-new_group + attributes: + attrib1: value1 + attrib2: value2 + attrib3: + - item1 + - item2 + register: result + +- name: Assert group created with attributes + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "my-new_group" + - result.end_state.path == "/my-new_group" + - result.end_state.clientRoles == {} + - result.end_state.realmRoles == [] + - result.end_state.subGroups == [] + - result.end_state.attributes != {} + - result.end_state.attributes.attrib1 == ["value1"] + - result.end_state.attributes.attrib2 == ["value2"] + - result.end_state.attributes.attrib3 == ["item1", "item2"] + +- name: Delete group with attributes by name + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: my-new_group + state: absent + register: result + +- name: Assert group with attributes was deleted + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +# --- Subgroup tests --- + +- name: Create base group for subgroup testing + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: rootgrp + register: grp_root_result + +- name: Create subgroup using parent id + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: subgrp1 + parents: + - id: "{{ grp_root_result.end_state.id }}" + register: result + +- name: Assert subgroup created by parent id + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "subgrp1" + - result.end_state.path == "/rootgrp/subgrp1" + - result.end_state.attributes == {} + - result.end_state.clientRoles == {} + - result.end_state.realmRoles == [] + - result.end_state.subGroups == [] + +- name: Recreate subgroup using parent id (idempotency) + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: subgrp1 + parents: + - id: "{{ grp_root_result.end_state.id }}" + register: result + +- name: Assert subgroup unchanged + ansible.builtin.assert: + that: + - result is not changed + - result.end_state != {} + - result.end_state.name == "subgrp1" + - result.end_state.path == "/rootgrp/subgrp1" + - result.end_state.attributes == {} + - result.end_state.clientRoles == {} + - result.end_state.realmRoles == [] + - result.end_state.subGroups == [] + +- name: Rename subgroup + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + id: "{{ result.end_state.id }}" + name: new-subgrp1 + parents: + - id: "{{ grp_root_result.end_state.id }}" + register: result + +- name: Assert subgroup renamed + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "new-subgrp1" + - result.end_state.path == "/rootgrp/new-subgrp1" + - result.end_state.attributes == {} + - result.end_state.clientRoles == {} + - result.end_state.realmRoles == [] + - result.end_state.subGroups == [] + +- name: Create subgroup using parent name + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: subgrp2 + parents: + - name: rootgrp + register: result + +- name: Assert subgroup created by parent name + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "subgrp2" + - result.end_state.path == "/rootgrp/subgrp2" + - result.end_state.attributes == {} + - result.end_state.clientRoles == {} + - result.end_state.realmRoles == [] + - result.end_state.subGroups == [] + +- name: Recreate subgroup using parent name (idempotency) + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: subgrp2 + parents: + - name: rootgrp + register: result + +- name: Assert subgroup unchanged + ansible.builtin.assert: + that: + - result is not changed + - result.end_state != {} + - result.end_state.name == "subgrp2" + - result.end_state.path == "/rootgrp/subgrp2" + - result.end_state.attributes == {} + - result.end_state.clientRoles == {} + - result.end_state.realmRoles == [] + - result.end_state.subGroups == [] + +# --- Sub-subgroup (deep chain) --- + +- name: Create sub-subgroup using parent name chain + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: subsubgrp + parents: + - name: rootgrp + - name: subgrp2 + register: result + +- name: Assert sub-subgroup created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "subsubgrp" + - result.end_state.path == "/rootgrp/subgrp2/subsubgrp" + - result.end_state.attributes == {} + - result.end_state.clientRoles == {} + - result.end_state.realmRoles == [] + - result.end_state.subGroups == [] + +- name: Recreate sub-subgroup using parent names (idempotency) + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: subsubgrp + parents: + - name: rootgrp + - name: subgrp2 + register: result_subsub + +- name: Assert sub-subgroup unchanged + ansible.builtin.assert: + that: + - result_subsub is not changed + - result_subsub.end_state != {} + - result_subsub.end_state.name == "subsubgrp" + - result_subsub.end_state.path == "/rootgrp/subgrp2/subsubgrp" + - result_subsub.end_state.attributes == {} + - result_subsub.end_state.clientRoles == {} + - result_subsub.end_state.realmRoles == [] + - result_subsub.end_state.subGroups == [] + +- name: Create sub-sub-subgroup using direct parent id + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: subsubsubgrp + parents: + - id: "{{ result_subsub.end_state.id }}" + register: result + +- name: Assert sub-sub-subgroup created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "subsubsubgrp" + - result.end_state.path == "/rootgrp/subgrp2/subsubgrp/subsubsubgrp" + - result.end_state.attributes == {} + - result.end_state.clientRoles == {} + - result.end_state.realmRoles == [] + - result.end_state.subGroups == [] + +- name: Recreate sub-sub-subgroup using direct parent id (idempotency) + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: subsubsubgrp + parents: + - id: "{{ result_subsub.end_state.id }}" + register: result_subsubsub + +- name: Assert sub-sub-subgroup unchanged + ansible.builtin.assert: + that: + - result_subsubsub is not changed + - result_subsubsub.end_state != {} + - result_subsubsub.end_state.name == "subsubsubgrp" + - result_subsubsub.end_state.path == "/rootgrp/subgrp2/subsubgrp/subsubsubgrp" + - result_subsubsub.end_state.attributes == {} + - result_subsubsub.end_state.clientRoles == {} + - result_subsubsub.end_state.realmRoles == [] + - result_subsubsub.end_state.subGroups == [] + +# --- Subgroup deletion --- + +- name: Delete subgroup by id (no parents needed) + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + id: "{{ result_subsubsub.end_state.id }}" + state: absent + register: result + +- name: Assert subgroup deleted by id + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Redo subgroup deletion by id (idempotency) + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + id: "{{ result_subsubsub.end_state.id }}" + state: absent + register: result + +- name: Assert subgroup deletion idempotent + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} + +- name: Delete subgroup by name with parents + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: new-subgrp1 + parents: + - name: rootgrp + state: absent + register: result + +- name: Assert subgroup deleted by name + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Redo subgroup deletion by name (idempotency) + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: new-subgrp1 + parents: + - name: rootgrp + state: absent + register: result + +- name: Assert subgroup name deletion idempotent + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} + +- name: Delete group that has subgroups (cascade) + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: rootgrp + state: absent + register: result + +- name: Assert group with subgroups deleted + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Redo delete group with subgroups (idempotency) + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: rootgrp + state: absent + register: result + +- name: Assert group deletion idempotent + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} diff --git a/molecule/keycloak_modules/keycloak_group_rolemapping/vars.yml b/molecule/keycloak_modules/keycloak_group_rolemapping/vars.yml new file mode 100644 index 0000000..b76b648 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_group_rolemapping/vars.yml @@ -0,0 +1,4 @@ +--- +role_1: myrole-1 +role_2: myrole-2 +test_group: mygroup diff --git a/molecule/keycloak_modules/keycloak_group_rolemapping/verify.yml b/molecule/keycloak_modules/keycloak_group_rolemapping/verify.yml new file mode 100644 index 0000000..c57d03c --- /dev/null +++ b/molecule/keycloak_modules/keycloak_group_rolemapping/verify.yml @@ -0,0 +1,113 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_group_rolemapping +# Tests full map/unmap lifecycle with idempotency for realm role mappings on groups. + +- name: Load group rolemapping test variables + ansible.builtin.include_vars: + file: vars.yml + +- name: Create realm roles + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: "{{ item }}" + state: present + loop: + - "{{ role_1 }}" + - "{{ role_2 }}" + +- name: Create group + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: "{{ test_group }}" + state: present + +- name: Map realm roles to group + middleware_automation.keycloak.keycloak_realm_rolemapping: + realm: "{{ ephemeral_realm }}" + group_name: "{{ test_group }}" + roles: + - name: "{{ role_1 }}" + - name: "{{ role_2 }}" + state: present + register: result + +- name: Assert realm roles are assigned to group + ansible.builtin.assert: + that: + - result is changed + - result.end_state | count == 2 + +- name: Map realm roles to group again (idempotency) + middleware_automation.keycloak.keycloak_realm_rolemapping: + realm: "{{ ephemeral_realm }}" + group_name: "{{ test_group }}" + roles: + - name: "{{ role_1 }}" + - name: "{{ role_2 }}" + state: present + register: result + +- name: Assert realm roles stay assigned to group + ansible.builtin.assert: + that: + - result is not changed + +- name: Unmap realm role 1 from group + middleware_automation.keycloak.keycloak_realm_rolemapping: + realm: "{{ ephemeral_realm }}" + group_name: "{{ test_group }}" + roles: + - name: "{{ role_1 }}" + state: absent + register: result + +- name: Assert realm role 1 is unassigned from group + ansible.builtin.assert: + that: + - result is changed + - result.end_state | count == 1 + - result.end_state[0] == role_2 + +- name: Unmap realm role 1 from group again (idempotency) + middleware_automation.keycloak.keycloak_realm_rolemapping: + realm: "{{ ephemeral_realm }}" + group_name: "{{ test_group }}" + roles: + - name: "{{ role_1 }}" + state: absent + register: result + +- name: Assert realm role 1 stays unassigned from group + ansible.builtin.assert: + that: + - result is not changed + +- name: Unmap realm role 2 from group + middleware_automation.keycloak.keycloak_realm_rolemapping: + realm: "{{ ephemeral_realm }}" + group_name: "{{ test_group }}" + roles: + - name: "{{ role_2 }}" + state: absent + register: result + +- name: Assert no realm roles are assigned to group + ansible.builtin.assert: + that: + - result is changed + - result.end_state | count == 0 + +- name: Unmap realm role 2 from group again (idempotency) + middleware_automation.keycloak.keycloak_realm_rolemapping: + realm: "{{ ephemeral_realm }}" + group_name: "{{ test_group }}" + roles: + - name: "{{ role_2 }}" + state: absent + register: result + +- name: Assert no realm roles are assigned to group + ansible.builtin.assert: + that: + - result is not changed + - result.end_state | count == 0 diff --git a/molecule/keycloak_modules/keycloak_identity_provider/verify.yml b/molecule/keycloak_modules/keycloak_identity_provider/verify.yml new file mode 100644 index 0000000..1804827 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_identity_provider/verify.yml @@ -0,0 +1,264 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_identity_provider +# Tests create with mappers, mapper CRUD, update, clientSecret masking, delete idempotency, fromUrl discovery. + +- name: Create new identity provider + middleware_automation.keycloak.keycloak_identity_provider: + realm: "{{ ephemeral_realm }}" + alias: myidp + display_name: OpenID Connect IdP + enabled: true + provider_id: oidc + config: + issuer: https://idp.example.com + authorizationUrl: https://idp.example.com/auth + tokenUrl: https://idp.example.com/token + userInfoUrl: https://idp.example.com/userinfo + clientAuthMethod: client_secret_post + clientId: clientid + clientSecret: clientsecret + syncMode: FORCE + mappers: + - name: "first_name" + identityProviderAlias: myidp + identityProviderMapper: "oidc-user-attribute-idp-mapper" + config: + claim: "first_name" + user.attribute: "first_name" + syncMode: "INHERIT" + - name: "last_name" + identityProviderAlias: myidp + identityProviderMapper: "oidc-user-attribute-idp-mapper" + config: + claim: "last_name" + user.attribute: "last_name" + syncMode: "INHERIT" + state: present + register: result + +- name: Assert identity provider created + ansible.builtin.assert: + that: + - result is changed + - result.existing == {} + - result.end_state.alias == "myidp" + - result.end_state.mappers != [] + - result.end_state.config.clientSecret == "**********" + +- name: Update existing identity provider (no change) + middleware_automation.keycloak.keycloak_identity_provider: + realm: "{{ ephemeral_realm }}" + alias: myidp + enabled: true + provider_id: oidc + config: + issuer: https://idp.example.com + authorizationUrl: https://idp.example.com/auth + tokenUrl: https://idp.example.com/token + userInfoUrl: https://idp.example.com/userinfo + clientAuthMethod: client_secret_post + clientId: clientid + clientSecret: "**********" + syncMode: FORCE + mappers: + - name: "first_name" + identityProviderAlias: myidp + identityProviderMapper: "oidc-user-attribute-idp-mapper" + config: + claim: "first_name" + user.attribute: "first_name" + syncMode: "INHERIT" + - name: "last_name" + identityProviderAlias: myidp + identityProviderMapper: "oidc-user-attribute-idp-mapper" + config: + claim: "last_name" + user.attribute: "last_name" + syncMode: "INHERIT" + state: present + register: result + +- name: Assert identity provider unchanged + ansible.builtin.assert: + that: + - result is not changed + +- name: Update existing identity provider (with change, no mapper change) + middleware_automation.keycloak.keycloak_identity_provider: + realm: "{{ ephemeral_realm }}" + alias: myidp + enabled: false + state: present + register: result + +- name: Assert identity provider updated + ansible.builtin.assert: + that: + - result is changed + - result.existing.enabled == true + - result.end_state.enabled == false + +- name: Update existing identity provider (delete mapper) + middleware_automation.keycloak.keycloak_identity_provider: + realm: "{{ ephemeral_realm }}" + alias: myidp + state: present + mappers: + - name: "first_name" + identityProviderAlias: myidp + identityProviderMapper: "oidc-user-attribute-idp-mapper" + config: + claim: "first_name" + user.attribute: "first_name" + syncMode: "INHERIT" + register: result + +- name: Assert identity provider updated + ansible.builtin.assert: + that: + - result is changed + - result.existing.mappers | length == 2 + - result.end_state.mappers | length == 1 + - result.end_state.mappers[0].name == "first_name" + +- name: Update existing identity provider (add mapper) + middleware_automation.keycloak.keycloak_identity_provider: + realm: "{{ ephemeral_realm }}" + alias: myidp + state: present + mappers: + - name: "last_name" + identityProviderAlias: myidp + identityProviderMapper: "oidc-user-attribute-idp-mapper" + config: + claim: "last_name" + user.attribute: "last_name" + syncMode: "INHERIT" + - name: "first_name" + identityProviderAlias: myidp + identityProviderMapper: "oidc-user-attribute-idp-mapper" + config: + claim: "first_name" + user.attribute: "first_name" + syncMode: "INHERIT" + register: result + +- name: Assert identity provider updated + ansible.builtin.assert: + that: + - result is changed + - result.existing.mappers | length == 1 + - result.end_state.mappers | length == 2 + +- name: Update existing identity provider (no change, test mapper idempotency) + middleware_automation.keycloak.keycloak_identity_provider: + realm: "{{ ephemeral_realm }}" + alias: myidp + state: present + mappers: + - name: "last_name" + identityProviderAlias: myidp + identityProviderMapper: "oidc-user-attribute-idp-mapper" + config: + claim: "last_name" + user.attribute: "last_name" + syncMode: "INHERIT" + - name: "first_name" + identityProviderAlias: myidp + identityProviderMapper: "oidc-user-attribute-idp-mapper" + config: + claim: "first_name" + user.attribute: "first_name" + syncMode: "INHERIT" + register: result + +- name: Assert identity provider updated + ansible.builtin.assert: + that: + - result is not changed + +- name: Delete existing identity provider + middleware_automation.keycloak.keycloak_identity_provider: + realm: "{{ ephemeral_realm }}" + alias: myidp + state: absent + register: result + +- name: Assert identity provider deleted + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Delete absent identity provider + middleware_automation.keycloak.keycloak_identity_provider: + realm: "{{ ephemeral_realm }}" + alias: myidp + state: absent + register: result + +- name: Assert identity provider unchanged + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} + +- name: Create IDP realm + middleware_automation.keycloak.keycloak_realm: + id: myidprealm + realm: myidprealm + state: present + +- name: Create new identity provider with fromUrl + middleware_automation.keycloak.keycloak_identity_provider: + realm: "{{ ephemeral_realm }}" + alias: myidpfromurl + display_name: OpenID Connect IdP from url + enabled: true + provider_id: oidc + config: + fromUrl: "{{ auth_keycloak_url }}/realms/myidprealm/.well-known/openid-configuration" + clientAuthMethod: client_secret_post + clientId: clientid + clientSecret: clientsecret + syncMode: FORCE + state: present + register: result + +- name: Assert identity provider created with IDP endpoints + ansible.builtin.assert: + that: + - result is changed + - result.end_state.config.authorizationUrl == auth_keycloak_url ~ "/realms/myidprealm/protocol/openid-connect/auth" + - result.end_state.config.issuer == auth_keycloak_url ~ "/realms/myidprealm" + - result.end_state.config.jwksUrl == auth_keycloak_url ~ "/realms/myidprealm/protocol/openid-connect/certs" + - result.end_state.config.logoutUrl == auth_keycloak_url ~ "/realms/myidprealm/protocol/openid-connect/logout" + - result.end_state.config.tokenUrl == auth_keycloak_url ~ "/realms/myidprealm/protocol/openid-connect/token" + - result.end_state.config.userInfoUrl == auth_keycloak_url ~ "/realms/myidprealm/protocol/openid-connect/userinfo" + +- name: Create new identity provider with fromUrl and exclusion should fail + middleware_automation.keycloak.keycloak_identity_provider: + realm: "{{ ephemeral_realm }}" + alias: "mustfail" + display_name: Failed OpenID Connect IdP from url + enabled: true + provider_id: oidc + config: "{{ config | combine(endpoint) }}" + state: present + vars: + config: + fromUrl: "{{ auth_keycloak_url }}/realms/myidprealm/.well-known/openid-configuration" + clientAuthMethod: client_secret_post + clientId: clientid + clientSecret: clientsecret + endpoint: "{{ { item: auth_keycloak_url ~ '/realms/myidprealm/protocol/openid-connect/' ~ item } }}" + with_items: ['userInfoUrl', 'authorizationUrl', 'tokenUrl', 'logoutUrl', 'issuer', 'jwksUrl'] + register: result + ignore_errors: true + +- name: Check failure of identity provider creation with fromUrl and userInfoUrl + ansible.builtin.assert: + that: + - result is not changed + - result is failed + - result.results | selectattr('failed', 'equalto', false) | list | length == 0 diff --git a/molecule/keycloak_modules/keycloak_modules_authentication/vars.yml b/molecule/keycloak_modules/keycloak_modules_authentication/vars.yml new file mode 100644 index 0000000..c974aa9 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_modules_authentication/vars.yml @@ -0,0 +1,4 @@ +--- +client_secret: myclientsecret +auth_test_role: myrole +keycloak_role_description: test diff --git a/molecule/keycloak_modules/keycloak_modules_authentication/verify.yml b/molecule/keycloak_modules/keycloak_modules_authentication/verify.yml new file mode 100644 index 0000000..c645c07 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_modules_authentication/verify.yml @@ -0,0 +1,281 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_modules_authentication +# Tests the authentication layer shared by all keycloak modules: +# token auth, refresh token fallback, auth fallback chains, client_credentials, and 401 errors. + +- name: Load authentication test variables + ansible.builtin.include_vars: + file: vars.yml + +- name: Reset public login in master admin-cli (if potentially previous test failed) + middleware_automation.keycloak.keycloak_client: + auth_keycloak_url: "{{ auth_keycloak_url }}" + auth_realm: master + auth_username: "{{ auth_username }}" + auth_password: "{{ auth_password }}" + auth_client_id: admin-cli + auth_client_secret: "{{ client_secret }}" + client_id: admin-cli + secret: "{{ client_secret }}" + public_client: true + state: present + +- name: Create new realm role with username/password authentication + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + description: "{{ keycloak_role_description }}" + state: present + register: result + +- name: Assert username/password authentication succeeded + ansible.builtin.assert: + that: + - result is changed + - result is not failed + +- name: Remove created realm role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + state: absent + register: result + +- name: Get Keycloak token + ansible.builtin.uri: + url: "{{ auth_keycloak_url }}/realms/master/protocol/openid-connect/token" + method: POST + return_content: true + status_code: 200 + body_format: form-urlencoded + body: + grant_type: "password" + client_id: "admin-cli" + username: "{{ auth_username }}" + password: "{{ auth_password }}" + register: token_response + +- name: Extract tokens + ansible.builtin.set_fact: + access_token: "{{ token_response.json.access_token }}" + refresh_token: "{{ token_response.json.refresh_token }}" + +- name: Create new realm role with provided token authentication + middleware_automation.keycloak.keycloak_role: + auth_keycloak_url: "{{ auth_keycloak_url }}" + token: "{{ access_token }}" + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + description: "{{ keycloak_role_description }}" + state: present + register: result + +- name: Assert token authentication succeeded + ansible.builtin.assert: + that: + - result is changed + - result is not failed + +- name: Remove created realm role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + state: absent + register: result + +- name: Create new realm role with invalid auth token and valid refresh token + middleware_automation.keycloak.keycloak_role: + auth_keycloak_url: "{{ auth_keycloak_url }}" + auth_realm: master + auth_username: "{{ auth_username }}" + auth_password: "{{ auth_password }}" + token: "invalidtoken!!!" + refresh_token: "{{ refresh_token }}" + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + description: "{{ keycloak_role_description }}" + state: present + register: result + +- name: Assert refresh token fallback authentication succeeded + ansible.builtin.assert: + that: + - result is changed + - result is not failed + +- name: Remove created realm role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + state: absent + register: result + +- name: Create new realm role with invalid auth token and valid username/password + middleware_automation.keycloak.keycloak_role: + auth_keycloak_url: "{{ auth_keycloak_url }}" + auth_realm: master + auth_username: "{{ auth_username }}" + auth_password: "{{ auth_password }}" + token: "invalidtoken!!!" + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + description: "{{ keycloak_role_description }}" + state: present + register: result + +- name: Assert username/password fallback authentication succeeded + ansible.builtin.assert: + that: + - result is changed + - result is not failed + +- name: Remove created realm role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + state: absent + register: result + +- name: Create new realm role with invalid auth token, invalid refresh token, and valid username/password + middleware_automation.keycloak.keycloak_role: + auth_keycloak_url: "{{ auth_keycloak_url }}" + auth_realm: master + auth_username: "{{ auth_username }}" + auth_password: "{{ auth_password }}" + token: "invalidtoken!!!" + refresh_token: "invalidrefreshtoken!!!" + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + description: "{{ keycloak_role_description }}" + state: present + register: result + +- name: Assert full fallback chain authentication succeeded + ansible.builtin.assert: + that: + - result is changed + - result is not failed + +- name: Remove created realm role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + state: absent + register: result + +- name: Test client_credentials authentication + block: + - name: PREPARE - Temporarily disable public login in master admin-cli + middleware_automation.keycloak.keycloak_client: + auth_keycloak_url: "{{ auth_keycloak_url }}" + auth_realm: master + auth_username: "{{ auth_username }}" + auth_password: "{{ auth_password }}" + auth_client_id: admin-cli + auth_client_secret: "{{ client_secret }}" + client_id: admin-cli + secret: "{{ client_secret }}" + public_client: false + service_accounts_enabled: true + client_authenticator_type: client-secret + state: present + + - name: PREPARE - Assign admin role to admin-cli in master + middleware_automation.keycloak.keycloak_user_rolemapping: + auth_keycloak_url: "{{ auth_keycloak_url }}" + auth_realm: master + auth_username: "{{ auth_username }}" + auth_password: "{{ auth_password }}" + auth_client_id: admin-cli + auth_client_secret: "{{ client_secret }}" + realm: master + roles: + - name: admin + service_account_user_client_id: admin-cli + + - name: Create new realm role with valid client_id and client_secret + middleware_automation.keycloak.keycloak_role: + auth_keycloak_url: "{{ auth_keycloak_url }}" + auth_realm: master + auth_client_id: admin-cli + auth_client_secret: "{{ client_secret }}" + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + description: "{{ keycloak_role_description }}" + state: present + register: result + + - name: Assert client_credentials authentication succeeded + ansible.builtin.assert: + that: + - result is changed + - result is not failed + always: + - name: Reset temporarily disabled public login in master admin-cli + middleware_automation.keycloak.keycloak_client: + auth_keycloak_url: "{{ auth_keycloak_url }}" + auth_realm: master + auth_username: "{{ auth_username }}" + auth_password: "{{ auth_password }}" + auth_client_id: admin-cli + auth_client_secret: "{{ client_secret }}" + client_id: admin-cli + secret: "{{ client_secret }}" + public_client: true + state: present + +- name: Remove created realm role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + state: absent + register: result + +### Unhappy path tests + +- name: Fail to create new realm role with invalid username/password + middleware_automation.keycloak.keycloak_role: + auth_keycloak_url: "{{ auth_keycloak_url }}" + auth_realm: master + auth_username: "{{ auth_username }}" + auth_password: "invalid_password" + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + description: "{{ keycloak_role_description }}" + state: present + register: result + failed_when: > + ("HTTP Error 401: Unauthorized" not in result.msg) and + ("HTTP Error 400: Bad Request" not in result.msg) + +- name: Fail to create new realm role with invalid auth token + middleware_automation.keycloak.keycloak_role: + auth_keycloak_url: "{{ auth_keycloak_url }}" + auth_username: "" + auth_password: "" + token: "invalidtoken!!!" + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + description: "{{ keycloak_role_description }}" + state: present + register: result + failed_when: > + ("HTTP Error 401: Unauthorized" not in result.msg) and + ("HTTP Error 400: Bad Request" not in result.msg) + +- name: Fail to create new realm role with invalid auth and refresh tokens, and invalid username/password + middleware_automation.keycloak.keycloak_role: + auth_keycloak_url: "{{ auth_keycloak_url }}" + auth_realm: master + auth_username: "{{ auth_username }}" + auth_password: "invalid_password" + token: "invalidtoken!!!" + refresh_token: "invalidtoken!!!" + realm: "{{ ephemeral_realm }}" + name: "{{ auth_test_role }}" + description: "{{ keycloak_role_description }}" + state: present + register: result + failed_when: > + ("HTTP Error 401: Unauthorized" not in result.msg) and + ("HTTP Error 400: Bad Request" not in result.msg) diff --git a/molecule/keycloak_modules/keycloak_realm/verify.yml b/molecule/keycloak_modules/keycloak_realm/verify.yml new file mode 100644 index 0000000..7a40299 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_realm/verify.yml @@ -0,0 +1,56 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_realm +# Tests session timeout and OAuth2 device settings on keycloak_realm module. + +- name: Modify realm + middleware_automation.keycloak.keycloak_realm: + id: "{{ ephemeral_realm }}" + realm: "{{ ephemeral_realm }}" + client_session_idle_timeout: 240 + client_session_max_lifespan: 21600 + client_offline_session_idle_timeout: 100 + client_offline_session_max_lifespan: 200 + oauth2_device_code_lifespan: 700 + oauth2_device_polling_interval: 800 + state: present + register: result + +- name: Assert result + ansible.builtin.assert: + that: + - result is changed + - result.end_state.clientSessionIdleTimeout == 240 + - result.end_state.clientSessionMaxLifespan == 21600 + - result.end_state.clientOfflineSessionIdleTimeout == 100 + - result.end_state.clientOfflineSessionMaxLifespan == 200 + - result.end_state.oauth2DeviceCodeLifespan == 700 + - result.end_state.oauth2DevicePollingInterval == 800 + +- name: Delete realm + middleware_automation.keycloak.keycloak_realm: + realm: "{{ ephemeral_realm }}" + state: absent + +- name: create realm + middleware_automation.keycloak.keycloak_realm: + id: "{{ ephemeral_realm }}" + realm: "{{ ephemeral_realm }}" + client_session_idle_timeout: 240 + client_session_max_lifespan: 21600 + client_offline_session_idle_timeout: 100 + client_offline_session_max_lifespan: 200 + oauth2_device_code_lifespan: 700 + oauth2_device_polling_interval: 800 + state: present + register: result + +- name: Assert result + ansible.builtin.assert: + that: + - result is changed + - result.end_state.clientSessionIdleTimeout == 240 + - result.end_state.clientSessionMaxLifespan == 21600 + - result.end_state.clientOfflineSessionIdleTimeout == 100 + - result.end_state.clientOfflineSessionMaxLifespan == 200 + - result.end_state.oauth2DeviceCodeLifespan == 700 + - result.end_state.oauth2DevicePollingInterval == 800 diff --git a/molecule/keycloak_modules/keycloak_realm_key/verify.yml b/molecule/keycloak_modules/keycloak_realm_key/verify.yml new file mode 100644 index 0000000..62849cc --- /dev/null +++ b/molecule/keycloak_modules/keycloak_realm_key/verify.yml @@ -0,0 +1,526 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_realm_key +# Tests auto-generated key providers: HMAC, AES, ECDSA, RSA, RSA-ENC, ECDH, EdDSA. +# Skips RSA with private key (needs external key material) and Java Keystore (needs keystore file). + +# --- HMAC generated key --- + +- name: Create HMAC key (check mode) + middleware_automation.keycloak.keycloak_realm_key: + name: hmac-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: hmac-generated + config: + enabled: true + active: true + priority: 100 + algorithm: HS256 + secret_size: 64 + check_mode: true + register: result + +- name: Assert HMAC key would be created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "hmac-test-key" + - result.end_state.providerId == "hmac-generated" + - result.end_state.config.algorithm == ["HS256"] + - result.end_state.config.secretSize == ["64"] + - result.msg == "Realm key hmac-test-key would be created" + +- name: Create HMAC key + middleware_automation.keycloak.keycloak_realm_key: + name: hmac-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: hmac-generated + config: + enabled: true + active: true + priority: 100 + algorithm: HS256 + secret_size: 64 + register: result + +- name: Assert HMAC key was created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "hmac-test-key" + - result.end_state.providerId == "hmac-generated" + - result.end_state.providerType == "org.keycloak.keys.KeyProvider" + - result.end_state.config.algorithm == ["HS256"] + - result.end_state.config.secretSize == ["64"] + - result.msg == "Realm key hmac-test-key created" + +- name: Create HMAC key (idempotency) + middleware_automation.keycloak.keycloak_realm_key: + name: hmac-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: hmac-generated + config: + enabled: true + active: true + priority: 100 + algorithm: HS256 + secret_size: 64 + register: result + +- name: Assert HMAC key is in sync + ansible.builtin.assert: + that: + - result is not changed + - result.msg == "Realm key hmac-test-key was in sync" + +- name: Update HMAC key priority + middleware_automation.keycloak.keycloak_realm_key: + name: hmac-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: hmac-generated + config: + enabled: true + active: true + priority: 110 + algorithm: HS256 + secret_size: 64 + register: result + +- name: Assert HMAC key was updated + ansible.builtin.assert: + that: + - result is changed + - result.end_state.config.priority == ["110"] + - "'config.priority' in result.msg" + +- name: Remove HMAC key + middleware_automation.keycloak.keycloak_realm_key: + name: hmac-test-key + state: absent + parent_id: "{{ ephemeral_realm }}" + provider_id: hmac-generated + config: + priority: 110 + register: result + +- name: Assert HMAC key was deleted + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + - result.msg == "Realm key hmac-test-key deleted" + +# --- AES generated key --- + +- name: Create AES key + middleware_automation.keycloak.keycloak_realm_key: + name: aes-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: aes-generated + config: + enabled: true + active: true + priority: 100 + secret_size: 32 + register: result + +- name: Assert AES key was created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "aes-test-key" + - result.end_state.providerId == "aes-generated" + - result.end_state.config.secretSize == ["32"] + - result.msg == "Realm key aes-test-key created" + +- name: Create AES key (idempotency) + middleware_automation.keycloak.keycloak_realm_key: + name: aes-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: aes-generated + config: + enabled: true + active: true + priority: 100 + secret_size: 32 + register: result + +- name: Assert AES key is in sync + ansible.builtin.assert: + that: + - result is not changed + - result.msg == "Realm key aes-test-key was in sync" + +- name: Remove AES key + middleware_automation.keycloak.keycloak_realm_key: + name: aes-test-key + state: absent + parent_id: "{{ ephemeral_realm }}" + provider_id: aes-generated + config: + priority: 100 + register: result + +- name: Assert AES key was deleted + ansible.builtin.assert: + that: + - result is changed + - result.msg == "Realm key aes-test-key deleted" + +# --- ECDSA generated key --- + +- name: Create ECDSA key + middleware_automation.keycloak.keycloak_realm_key: + name: ecdsa-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: ecdsa-generated + config: + enabled: true + active: true + priority: 100 + algorithm: ES256 + elliptic_curve: P-256 + register: result + +- name: Assert ECDSA key was created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "ecdsa-test-key" + - result.end_state.providerId == "ecdsa-generated" + - result.end_state.config.algorithm == ["ES256"] + - result.end_state.config.ecdsaEllipticCurveKey == ["P-256"] + - result.msg == "Realm key ecdsa-test-key created" + +- name: Create ECDSA key (idempotency) + middleware_automation.keycloak.keycloak_realm_key: + name: ecdsa-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: ecdsa-generated + config: + enabled: true + active: true + priority: 100 + algorithm: ES256 + elliptic_curve: P-256 + register: result + +- name: Assert ECDSA key is in sync + ansible.builtin.assert: + that: + - result is not changed + - result.msg == "Realm key ecdsa-test-key was in sync" + +- name: Remove ECDSA key + middleware_automation.keycloak.keycloak_realm_key: + name: ecdsa-test-key + state: absent + parent_id: "{{ ephemeral_realm }}" + provider_id: ecdsa-generated + config: + priority: 100 + register: result + +- name: Assert ECDSA key was deleted + ansible.builtin.assert: + that: + - result is changed + - result.msg == "Realm key ecdsa-test-key deleted" + +# --- RSA generated key --- + +- name: Create RSA generated key + middleware_automation.keycloak.keycloak_realm_key: + name: rsa-gen-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: rsa-generated + config: + enabled: true + active: true + priority: 100 + algorithm: RS256 + key_size: 2048 + register: result + +- name: Assert RSA generated key was created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "rsa-gen-test-key" + - result.end_state.providerId == "rsa-generated" + - result.end_state.config.algorithm == ["RS256"] + - result.end_state.config.keySize == ["2048"] + - result.msg == "Realm key rsa-gen-test-key created" + +- name: Create RSA generated key (idempotency) + middleware_automation.keycloak.keycloak_realm_key: + name: rsa-gen-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: rsa-generated + config: + enabled: true + active: true + priority: 100 + algorithm: RS256 + key_size: 2048 + register: result + +- name: Assert RSA generated key is in sync + ansible.builtin.assert: + that: + - result is not changed + - result.msg == "Realm key rsa-gen-test-key was in sync" + +- name: Remove RSA generated key + middleware_automation.keycloak.keycloak_realm_key: + name: rsa-gen-test-key + state: absent + parent_id: "{{ ephemeral_realm }}" + provider_id: rsa-generated + config: + priority: 100 + register: result + +- name: Assert RSA generated key was deleted + ansible.builtin.assert: + that: + - result is changed + - result.msg == "Realm key rsa-gen-test-key deleted" + +# --- Default realm key management --- + +- name: Update priority of default hmac-generated key + middleware_automation.keycloak.keycloak_realm_key: + name: hmac-generated + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: hmac-generated + config: + enabled: true + active: true + priority: 150 + algorithm: HS256 + register: result + +- name: Assert default hmac-generated key was updated + ansible.builtin.assert: + that: + - result is changed + - result.end_state.config.priority == ["150"] + +- name: Remove default hmac-generated key + middleware_automation.keycloak.keycloak_realm_key: + name: hmac-generated + state: absent + parent_id: "{{ ephemeral_realm }}" + provider_id: hmac-generated + config: + priority: 150 + register: result + +- name: Assert default hmac-generated key was deleted + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + - result.msg == "Realm key hmac-generated deleted" + +# --- RSA encryption generated key --- + +- name: Create RSA encryption key + middleware_automation.keycloak.keycloak_realm_key: + name: rsa-enc-gen-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: rsa-enc-generated + config: + enabled: true + active: true + priority: 100 + algorithm: RSA-OAEP + key_size: 2048 + register: result + +- name: Assert RSA encryption key was created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "rsa-enc-gen-test-key" + - result.end_state.providerId == "rsa-enc-generated" + - result.end_state.config.algorithm == ["RSA-OAEP"] + - result.end_state.config.keySize == ["2048"] + - result.msg == "Realm key rsa-enc-gen-test-key created" + +- name: Create RSA encryption key (idempotency) + middleware_automation.keycloak.keycloak_realm_key: + name: rsa-enc-gen-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: rsa-enc-generated + config: + enabled: true + active: true + priority: 100 + algorithm: RSA-OAEP + key_size: 2048 + register: result + +- name: Assert RSA encryption key is in sync + ansible.builtin.assert: + that: + - result is not changed + - result.msg == "Realm key rsa-enc-gen-test-key was in sync" + +- name: Remove RSA encryption key + middleware_automation.keycloak.keycloak_realm_key: + name: rsa-enc-gen-test-key + state: absent + parent_id: "{{ ephemeral_realm }}" + provider_id: rsa-enc-generated + config: + priority: 100 + register: result + +- name: Assert RSA encryption key was deleted + ansible.builtin.assert: + that: + - result is changed + - result.msg == "Realm key rsa-enc-gen-test-key deleted" + +# --- ECDH generated key --- + +- name: Create ECDH key + middleware_automation.keycloak.keycloak_realm_key: + name: ecdh-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: ecdh-generated + config: + enabled: true + active: true + priority: 100 + algorithm: ECDH_ES + elliptic_curve: P-256 + register: result + +- name: Assert ECDH key was created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "ecdh-test-key" + - result.end_state.providerId == "ecdh-generated" + - result.end_state.config.algorithm == ["ECDH_ES"] + - result.end_state.config.ecdhEllipticCurveKey == ["P-256"] + - result.msg == "Realm key ecdh-test-key created" + +- name: Create ECDH key (idempotency) + middleware_automation.keycloak.keycloak_realm_key: + name: ecdh-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: ecdh-generated + config: + enabled: true + active: true + priority: 100 + algorithm: ECDH_ES + elliptic_curve: P-256 + register: result + +- name: Assert ECDH key is in sync + ansible.builtin.assert: + that: + - result is not changed + - result.msg == "Realm key ecdh-test-key was in sync" + +- name: Remove ECDH key + middleware_automation.keycloak.keycloak_realm_key: + name: ecdh-test-key + state: absent + parent_id: "{{ ephemeral_realm }}" + provider_id: ecdh-generated + config: + priority: 100 + register: result + +- name: Assert ECDH key was deleted + ansible.builtin.assert: + that: + - result is changed + - result.msg == "Realm key ecdh-test-key deleted" + +# --- EdDSA generated key --- + +- name: Create EdDSA key + middleware_automation.keycloak.keycloak_realm_key: + name: eddsa-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: eddsa-generated + config: + enabled: true + active: true + priority: 100 + elliptic_curve: Ed25519 + register: result + +- name: Assert EdDSA key was created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.name == "eddsa-test-key" + - result.end_state.providerId == "eddsa-generated" + - result.end_state.config.eddsaEllipticCurveKey == ["Ed25519"] + - result.msg == "Realm key eddsa-test-key created" + +- name: Create EdDSA key (idempotency) + middleware_automation.keycloak.keycloak_realm_key: + name: eddsa-test-key + state: present + parent_id: "{{ ephemeral_realm }}" + provider_id: eddsa-generated + config: + enabled: true + active: true + priority: 100 + elliptic_curve: Ed25519 + register: result + +- name: Assert EdDSA key is in sync + ansible.builtin.assert: + that: + - result is not changed + - result.msg == "Realm key eddsa-test-key was in sync" + +- name: Remove EdDSA key + middleware_automation.keycloak.keycloak_realm_key: + name: eddsa-test-key + state: absent + parent_id: "{{ ephemeral_realm }}" + provider_id: eddsa-generated + config: + priority: 100 + register: result + +- name: Assert EdDSA key was deleted + ansible.builtin.assert: + that: + - result is changed + - result.msg == "Realm key eddsa-test-key deleted" diff --git a/molecule/keycloak_modules/keycloak_realm_users_info/vars.yml b/molecule/keycloak_modules/keycloak_realm_users_info/vars.yml new file mode 100644 index 0000000..2d7b5ae --- /dev/null +++ b/molecule/keycloak_modules/keycloak_realm_users_info/vars.yml @@ -0,0 +1,6 @@ +--- +keycloak_username: test +keycloak_user_groups: + - name: test + state: present + - name: test2 diff --git a/molecule/keycloak_modules/keycloak_realm_users_info/verify.yml b/molecule/keycloak_modules/keycloak_realm_users_info/verify.yml new file mode 100644 index 0000000..22a4cff --- /dev/null +++ b/molecule/keycloak_modules/keycloak_realm_users_info/verify.yml @@ -0,0 +1,57 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_realm_users_info +# Tests multi-user listing and group membership in realm users info response. + +- name: Load realm users info test variables + ansible.builtin.include_vars: + file: vars.yml + +- name: Create new groups + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: "{{ item.name }}" + state: present + loop: "{{ keycloak_user_groups }}" + +- name: Create user + middleware_automation.keycloak.keycloak_user: + username: "{{ keycloak_username }}" + realm: "{{ ephemeral_realm }}" + first_name: Ceciestes + last_name: Untestes + email: ceciestuntestes@test.com + groups: "{{ keycloak_user_groups }}" + state: present + register: create_result + +- name: Assert user is created + ansible.builtin.assert: + that: + - create_result.changed + - create_result.end_state.username == 'test' + - create_result.end_state.groups | length == 2 + +- name: Create another user + middleware_automation.keycloak.keycloak_user: + username: "testuser2" + realm: "{{ ephemeral_realm }}" + first_name: Ceciestes2 + last_name: Untestes2 + email: ceciestuntestes2@test.com + state: present + register: create_result2 + +- name: Get user info + middleware_automation.keycloak.keycloak_realm_users_info: + realm: "{{ ephemeral_realm }}" + register: user_infos + +- name: Add missing group info for comparison + ansible.builtin.set_fact: + user_info_with_groups: "{{ [user_infos.users[0] | combine({'groups': ['test', 'test2']}), user_infos.users[1] | combine({'groups': []}) ] }}" + +- name: Assert user info is returned correctly + ansible.builtin.assert: + that: + - not user_infos.changed + - "user_info_with_groups == [create_result.end_state, create_result2.end_state]" diff --git a/molecule/keycloak_modules/keycloak_role/vars.yml b/molecule/keycloak_modules/keycloak_role/vars.yml new file mode 100644 index 0000000..7c069f9 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_role/vars.yml @@ -0,0 +1,32 @@ +--- +description_1: role test desc 1 +description_2: role test desc 2 +keycloak_role_description: composite role test + +keycloak_role_composites: + - name: view-clients + client_id: "realm-management" + state: present + - name: query-clients + client_id: "realm-management" + state: present + - name: offline_access + state: present +keycloak_role_composites_with_aliases: + - name: view-clients + clientId: "realm-management" + state: present + - name: query-clients + clientId: "realm-management" + state: present + - name: offline_access + state: present +keycloak_role_composites_with_absent: + - name: view-clients + client_id: "realm-management" + state: present + - name: query-clients + client_id: "realm-management" + state: present + - name: offline_access + state: absent diff --git a/molecule/keycloak_modules/keycloak_role/verify.yml b/molecule/keycloak_modules/keycloak_role/verify.yml new file mode 100644 index 0000000..d381b45 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_role/verify.yml @@ -0,0 +1,335 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_role +# Tests full CRUD lifecycle for realm/client roles and composite role management. + +- name: Load role test variables + ansible.builtin.include_vars: + file: vars.yml + +# --- Realm role CRUD --- + +- name: Create realm role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: myrole-test + description: "{{ description_1 }}" + state: present + register: result + +- name: Assert realm role created + ansible.builtin.assert: + that: + - result is changed + - result.existing == {} + - result.end_state.name == "myrole-test" + - result.end_state.containerId == ephemeral_realm + +- name: Create realm role again (idempotency) + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: myrole-test + description: "{{ description_1 }}" + state: present + register: result + +- name: Assert realm role unchanged + ansible.builtin.assert: + that: + - result is not changed + +- name: Update realm role description + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: myrole-test + description: "{{ description_2 }}" + state: present + register: result + +- name: Assert realm role updated + ansible.builtin.assert: + that: + - result is changed + - result.existing.description == description_1 + - result.end_state.description == description_2 + +- name: Delete realm role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: myrole-test + state: absent + register: result + +- name: Assert realm role deleted + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Delete absent realm role (idempotency) + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: myrole-test + state: absent + register: result + +- name: Assert no change on absent realm role + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} + +# --- Client role CRUD --- + +- name: Create client for role tests + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: myclient + state: present + register: role_test_client + +- name: Create client role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + client_id: myclient + name: client-role-test + description: "{{ description_1 }}" + state: present + register: result + +- name: Assert client role created + ansible.builtin.assert: + that: + - result is changed + - result.existing == {} + - result.end_state.name == "client-role-test" + - result.end_state.containerId == role_test_client.end_state.id + +- name: Create client role again (idempotency) + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + client_id: myclient + name: client-role-test + description: "{{ description_1 }}" + state: present + register: result + +- name: Assert client role unchanged + ansible.builtin.assert: + that: + - result is not changed + +- name: Update client role description + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + client_id: myclient + name: client-role-test + description: "{{ description_2 }}" + state: present + register: result + +- name: Assert client role updated + ansible.builtin.assert: + that: + - result is changed + - result.existing.description == description_1 + - result.end_state.description == description_2 + +- name: Delete client role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + client_id: myclient + name: client-role-test + state: absent + register: result + +- name: Assert client role deleted + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Delete absent client role (idempotency) + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + client_id: myclient + name: client-role-test + state: absent + register: result + +- name: Assert no change on absent client role + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} + +# --- Composite realm roles --- + +- name: Create realm role with composites + middleware_automation.keycloak.keycloak_role: + name: composite-role + realm: "{{ ephemeral_realm }}" + description: "{{ keycloak_role_description }}" + composite: true + composites: "{{ keycloak_role_composites }}" + state: present + register: result + +- name: Assert realm role created with composites + ansible.builtin.assert: + that: + - result is changed + - result.end_state.composites | length == 3 + +- name: Realm role with composites (idempotency) + middleware_automation.keycloak.keycloak_role: + name: composite-role + realm: "{{ ephemeral_realm }}" + description: "{{ keycloak_role_description }}" + composite: true + composites: "{{ keycloak_role_composites }}" + state: present + register: result + +- name: Assert composites unchanged + ansible.builtin.assert: + that: + - result is not changed + - result.end_state.composites | length == 3 + +- name: Realm composites with aliases (idempotency) + middleware_automation.keycloak.keycloak_role: + name: composite-role + realm: "{{ ephemeral_realm }}" + description: "{{ keycloak_role_description }}" + composite: true + composites: "{{ keycloak_role_composites_with_aliases }}" + state: present + register: result + +- name: Assert composites unchanged with aliases + ansible.builtin.assert: + that: + - result is not changed + +- name: Remove one composite from realm role + middleware_automation.keycloak.keycloak_role: + name: composite-role + realm: "{{ ephemeral_realm }}" + description: "{{ keycloak_role_description }}" + composite: true + composites: "{{ keycloak_role_composites_with_absent }}" + state: present + register: result + +- name: Assert composite removed + ansible.builtin.assert: + that: + - result is changed + - result.end_state.composites | length == 2 + +- name: Delete composite realm role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: composite-role + state: absent + register: result + +- name: Assert composite role deleted + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Delete absent realm role with composites + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: composite-role + state: absent + register: result + +- name: Assert not changed and realm role absent + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} + +# --- Composite client roles --- + +- name: Create client role with composites + middleware_automation.keycloak.keycloak_role: + name: composite-client-role + client_id: myclient + realm: "{{ ephemeral_realm }}" + description: "{{ keycloak_role_description }}" + composite: true + composites: "{{ keycloak_role_composites }}" + state: present + register: result + +- name: Assert client role created with composites + ansible.builtin.assert: + that: + - result is changed + - result.end_state.composites | length == 3 + +- name: Client role with composites (idempotency) + middleware_automation.keycloak.keycloak_role: + name: composite-client-role + client_id: myclient + realm: "{{ ephemeral_realm }}" + description: "{{ keycloak_role_description }}" + composite: true + composites: "{{ keycloak_role_composites }}" + state: present + register: result + +- name: Assert client composites unchanged + ansible.builtin.assert: + that: + - result is not changed + - result.end_state.composites | length == 3 + +- name: Remove one composite from client role + middleware_automation.keycloak.keycloak_role: + name: composite-client-role + client_id: myclient + realm: "{{ ephemeral_realm }}" + description: "{{ keycloak_role_description }}" + composite: true + composites: "{{ keycloak_role_composites_with_absent }}" + state: present + register: result + +- name: Assert composite removed from client role + ansible.builtin.assert: + that: + - result is changed + - result.end_state.composites | length == 2 + +- name: Delete composite client role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: composite-client-role + client_id: myclient + state: absent + register: result + +- name: Assert composite client role deleted + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + +- name: Delete absent client role with composites + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: composite-client-role + client_id: myclient + state: absent + register: result + +- name: Assert not changed and client role absent + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} diff --git a/molecule/keycloak_modules/keycloak_user/vars.yml b/molecule/keycloak_modules/keycloak_user/vars.yml new file mode 100644 index 0000000..8007d85 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_user/vars.yml @@ -0,0 +1,19 @@ +--- +keycloak_username: test +keycloak_user_attributes: + - name: attr1 + values: + - value1s + state: present + - name: attr2 + values: + - value2s + state: present + - name: attr3 + values: + - value3s + state: present +keycloak_user_groups: + - name: test + state: present + - name: test2 diff --git a/molecule/keycloak_modules/keycloak_user/verify.yml b/molecule/keycloak_modules/keycloak_user/verify.yml new file mode 100644 index 0000000..a1e699d --- /dev/null +++ b/molecule/keycloak_modules/keycloak_user/verify.yml @@ -0,0 +1,221 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_user +# Tests: user with groups+attributes, plus-addressed email, email_verified default reset, +# required_actions explicit reset to empty list. + +- name: Load user test variables + ansible.builtin.include_vars: + file: vars.yml + +- name: Create new groups + middleware_automation.keycloak.keycloak_group: + realm: "{{ ephemeral_realm }}" + name: "{{ item.name }}" + state: present + loop: "{{ keycloak_user_groups }}" + +- name: Create user + middleware_automation.keycloak.keycloak_user: + username: "{{ keycloak_username }}" + realm: "{{ ephemeral_realm }}" + first_name: Ceciestes + last_name: Untestes + email: ceciestuntestes@test.com + groups: "{{ keycloak_user_groups }}" + attributes: "{{ keycloak_user_attributes }}" + state: present + register: create_result + +- name: Assert user is created + ansible.builtin.assert: + that: + - create_result.changed + - create_result.end_state.username == 'test' + - create_result.end_state.userProfileMetadata.attributes | length == 4 + - create_result.end_state.groups | length == 2 + +- name: Delete User + middleware_automation.keycloak.keycloak_user: + username: "{{ keycloak_username }}" + realm: "{{ ephemeral_realm }}" + first_name: Ceciestes + last_name: Untestes + email: ceciestuntestes@test.com + groups: "{{ keycloak_user_groups }}" + attributes: "{{ keycloak_user_attributes }}" + state: absent + register: delete_result + +- name: Assert user is deleted + ansible.builtin.assert: + that: + - delete_result.changed + - delete_result.end_state | length == 0 + +- name: Create user with plus-addressed email + middleware_automation.keycloak.keycloak_user: + username: "testuser+tag" + realm: "{{ ephemeral_realm }}" + first_name: Plus + last_name: User + email: "testuser+tag@example.org" + state: present + register: plus_create_result + +- name: Assert plus-addressed user is created + ansible.builtin.assert: + that: + - plus_create_result.changed + - plus_create_result.end_state.username == 'testuser+tag' + - plus_create_result.end_state.email == 'testuser+tag@example.org' + +- name: Re-run plus-addressed user creation (idempotency) + middleware_automation.keycloak.keycloak_user: + username: "testuser+tag" + realm: "{{ ephemeral_realm }}" + first_name: Plus + last_name: User + email: "testuser+tag@example.org" + state: present + register: plus_idempotent_result + +- name: Assert plus-addressed user is idempotent + ansible.builtin.assert: + that: + - plus_idempotent_result is not changed + +- name: Delete plus-addressed user + middleware_automation.keycloak.keycloak_user: + username: "testuser+tag" + realm: "{{ ephemeral_realm }}" + state: absent + register: plus_delete_result + +- name: Assert plus-addressed user is deleted + ansible.builtin.assert: + that: + - plus_delete_result.changed + +- name: Create user again + middleware_automation.keycloak.keycloak_user: + username: "{{ keycloak_username }}" + realm: "{{ ephemeral_realm }}" + first_name: Ceciestes + last_name: Untestes + email: ceciestuntestes@test.com + state: present + email_verified_behavior: no_defaults + register: create_result + +- name: Assert user is created without email_verified + ansible.builtin.assert: + that: + - create_result.changed + - create_result.end_state.username == 'test' + - create_result.end_state.emailVerified == false + +- name: Set email_verified + middleware_automation.keycloak.keycloak_user: + username: "{{ keycloak_username }}" + realm: "{{ ephemeral_realm }}" + first_name: Ceciestes + last_name: Untestes + email: ceciestuntestes@test.com + groups: "{{ keycloak_user_groups }}" + attributes: "{{ keycloak_user_attributes }}" + email_verified: true + state: present + register: create_result + +- name: Assert email_verified is set + ansible.builtin.assert: + that: + - create_result.changed + - create_result.end_state.emailVerified == True + +- name: Leave email_verified as it is + middleware_automation.keycloak.keycloak_user: + username: "{{ keycloak_username }}" + realm: "{{ ephemeral_realm }}" + first_name: Ceciestes + last_name: Untestes + email: ceciestuntestes@test.com + state: present + email_verified_behavior: no_defaults + register: create_result + +- name: Assert email_verified is still set + ansible.builtin.assert: + that: + - not create_result.changed + - create_result.end_state.emailVerified == True + +- name: Test old email_verified behavior + middleware_automation.keycloak.keycloak_user: + username: "{{ keycloak_username }}" + realm: "{{ ephemeral_realm }}" + first_name: Ceciestes + last_name: Untestes + email: ceciestuntestes@test.com + state: present + register: create_result + +- name: Assert email_verified is reset + ansible.builtin.assert: + that: + - create_result.changed + - create_result.end_state.emailVerified == False + +- name: Test setting required_actions + middleware_automation.keycloak.keycloak_user: + username: "{{ keycloak_username }}" + realm: "{{ ephemeral_realm }}" + first_name: Ceciestes + last_name: Untestes + email: ceciestuntestes@test.com + required_actions: + - UPDATE_PASSWORD + - VERIFY_EMAIL + state: present + register: create_result + +- name: Assert required_actions are set + ansible.builtin.assert: + that: + - create_result.changed + - "'UPDATE_PASSWORD' in create_result.end_state.requiredActions" + - "'VERIFY_EMAIL' in create_result.end_state.requiredActions" + +- name: Test required_actions unchanged + middleware_automation.keycloak.keycloak_user: + username: "{{ keycloak_username }}" + realm: "{{ ephemeral_realm }}" + first_name: Ceciestes + last_name: Untestes + email: ceciestuntestes@test.com + state: present + register: create_result + +- name: Assert required_actions are still set + ansible.builtin.assert: + that: + - not create_result.changed + - "'UPDATE_PASSWORD' in create_result.end_state.requiredActions" + - "'VERIFY_EMAIL' in create_result.end_state.requiredActions" + +- name: Test required_actions reset + middleware_automation.keycloak.keycloak_user: + username: "{{ keycloak_username }}" + realm: "{{ ephemeral_realm }}" + first_name: Ceciestes + last_name: Untestes + email: ceciestuntestes@test.com + state: present + required_actions: [] + register: create_result + +- name: Assert required_actions are reset + ansible.builtin.assert: + that: + - create_result.changed + - create_result.end_state.requiredActions == [] diff --git a/molecule/keycloak_modules/keycloak_user_federation/vars.yml b/molecule/keycloak_modules/keycloak_user_federation/vars.yml new file mode 100644 index 0000000..9646f2a --- /dev/null +++ b/molecule/keycloak_modules/keycloak_user_federation/vars.yml @@ -0,0 +1,2 @@ +--- +federation: myfed diff --git a/molecule/keycloak_modules/keycloak_user_federation/verify.yml b/molecule/keycloak_modules/keycloak_user_federation/verify.yml new file mode 100644 index 0000000..6b52bcd --- /dev/null +++ b/molecule/keycloak_modules/keycloak_user_federation/verify.yml @@ -0,0 +1,352 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_user_federation +# Tests full LDAP user federation lifecycle: create, idempotency (with masked credentials), +# update with mappers, delete, delete-absent, and create-with-mappers-in-one-step. + +- name: Load user federation test variables + ansible.builtin.include_vars: + file: vars.yml + +- name: Create new user federation + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ ephemeral_realm }}" + name: "{{ federation }}" + state: present + provider_id: ldap + provider_type: org.keycloak.storage.UserStorageProvider + config: + enabled: true + priority: 0 + fullSyncPeriod: -1 + changedSyncPeriod: -1 + cachePolicy: DEFAULT + batchSizeForSync: 1000 + editMode: READ_ONLY + importEnabled: true + syncRegistrations: false + vendor: other + usernameLDAPAttribute: uid + rdnLDAPAttribute: uid + uuidLDAPAttribute: entryUUID + userObjectClasses: "inetOrgPerson, organizationalPerson" + connectionUrl: "ldaps://ldap.example.com:636" + usersDn: "ou=Users,dc=example,dc=com" + authType: simple + bindDn: cn=directory reader + bindCredential: secret + searchScope: 1 + validatePasswordPolicy: false + trustEmail: false + useTruststoreSpi: "ldapsOnly" + connectionPooling: true + pagination: true + allowKerberosAuthentication: false + useKerberosForPasswordAuthentication: false + debug: false + register: result + +- name: Assert user federation created + ansible.builtin.assert: + that: + - result is changed + - result.existing == {} + - result.end_state.name == federation + +- name: Create new user federation in admin realm + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ auth_realm }}" + name: "{{ federation }}" + state: present + provider_id: ldap + provider_type: org.keycloak.storage.UserStorageProvider + config: + enabled: true + priority: 0 + fullSyncPeriod: -1 + changedSyncPeriod: -1 + cachePolicy: DEFAULT + batchSizeForSync: 1000 + editMode: READ_ONLY + importEnabled: true + syncRegistrations: false + vendor: other + usernameLDAPAttribute: uid + rdnLDAPAttribute: uid + uuidLDAPAttribute: entryUUID + userObjectClasses: "inetOrgPerson, organizationalPerson" + connectionUrl: "ldaps://ldap.example.com:636" + usersDn: "ou=Users,dc=example,dc=com" + authType: simple + bindDn: cn=directory reader + bindCredential: secret + searchScope: 1 + validatePasswordPolicy: false + trustEmail: false + useTruststoreSpi: "ldapsOnly" + connectionPooling: true + pagination: true + allowKerberosAuthentication: false + useKerberosForPasswordAuthentication: false + debug: false + register: result + +- name: Assert user federation created (admin realm) + ansible.builtin.assert: + that: + - result is changed + - result.existing == {} + - result.end_state.name == federation + +- name: Update existing user federation (no change) + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ ephemeral_realm }}" + name: "{{ federation }}" + state: present + provider_id: ldap + provider_type: org.keycloak.storage.UserStorageProvider + config: + enabled: true + priority: 0 + fullSyncPeriod: -1 + changedSyncPeriod: -1 + cachePolicy: DEFAULT + batchSizeForSync: 1000 + editMode: READ_ONLY + importEnabled: true + syncRegistrations: false + vendor: other + usernameLDAPAttribute: uid + rdnLDAPAttribute: uid + uuidLDAPAttribute: entryUUID + userObjectClasses: "inetOrgPerson, organizationalPerson" + connectionUrl: "ldaps://ldap.example.com:636" + usersDn: "ou=Users,dc=example,dc=com" + authType: simple + bindDn: cn=directory reader + bindCredential: "**********" + searchScope: 1 + validatePasswordPolicy: false + trustEmail: false + useTruststoreSpi: "ldapsOnly" + connectionPooling: true + pagination: true + allowKerberosAuthentication: false + useKerberosForPasswordAuthentication: false + debug: false + register: result + +- name: Assert user federation unchanged + ansible.builtin.assert: + that: + - result is not changed + - result.existing != {} + - result.existing.name == federation + - result.end_state != {} + - result.end_state.name == federation + +- name: Update existing user federation (no change, admin realm) + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ auth_realm }}" + name: "{{ federation }}" + state: present + provider_id: ldap + provider_type: org.keycloak.storage.UserStorageProvider + config: + enabled: true + priority: 0 + fullSyncPeriod: -1 + changedSyncPeriod: -1 + cachePolicy: DEFAULT + batchSizeForSync: 1000 + editMode: READ_ONLY + importEnabled: true + syncRegistrations: false + vendor: other + usernameLDAPAttribute: uid + rdnLDAPAttribute: uid + uuidLDAPAttribute: entryUUID + userObjectClasses: "inetOrgPerson, organizationalPerson" + connectionUrl: "ldaps://ldap.example.com:636" + usersDn: "ou=Users,dc=example,dc=com" + authType: simple + bindDn: cn=directory reader + bindCredential: "**********" + searchScope: 1 + validatePasswordPolicy: false + trustEmail: false + useTruststoreSpi: "ldapsOnly" + connectionPooling: true + pagination: true + allowKerberosAuthentication: false + useKerberosForPasswordAuthentication: false + debug: false + register: result + +- name: Assert user federation unchanged (admin realm) + ansible.builtin.assert: + that: + - result is not changed + - result.existing != {} + - result.existing.name == federation + - result.end_state != {} + - result.end_state.name == federation + +- name: Update existing user federation (with change) + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ ephemeral_realm }}" + name: "{{ federation }}" + state: present + provider_id: ldap + provider_type: org.keycloak.storage.UserStorageProvider + config: + enabled: true + priority: 0 + fullSyncPeriod: -1 + changedSyncPeriod: -1 + cachePolicy: DEFAULT + batchSizeForSync: 1000 + editMode: READ_ONLY + importEnabled: true + syncRegistrations: false + vendor: other + usernameLDAPAttribute: uid + rdnLDAPAttribute: uid + uuidLDAPAttribute: entryUUID + userObjectClasses: "inetOrgPerson, organizationalPerson" + connectionUrl: "ldaps://ldap.example.com:636" + usersDn: "ou=Users,dc=example,dc=com" + authType: simple + bindDn: cn=directory reader + bindCredential: "**********" + searchScope: 1 + validatePasswordPolicy: false + trustEmail: false + useTruststoreSpi: "ldapsOnly" + connectionPooling: true + pagination: true + allowKerberosAuthentication: false + useKerberosForPasswordAuthentication: false + debug: false + mappers: + - name: "username" + providerId: "user-attribute-ldap-mapper" + config: + ldap.attribute: ldap_user + user.model.attribute: usr + read.only: true + - name: "full name" + providerId: "full-name-ldap-mapper" + providerType: "org.keycloak.storage.ldap.mappers.LDAPStorageMapper" + config: + ldap.full.name.attribute: cn + read.only: true + write.only: false + register: result + +- name: Assert user federation created + ansible.builtin.assert: + that: + - result is changed + - result.existing != {} + - result.existing.name == federation + - result.end_state != {} + - result.end_state.name == federation + +- name: Delete existing user federation + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ ephemeral_realm }}" + name: "{{ federation }}" + state: absent + register: result + +- name: Assert user federation deleted + ansible.builtin.assert: + that: + - result is changed + - result.existing != {} + - result.end_state == {} + +- name: Delete absent user federation + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ ephemeral_realm }}" + name: "{{ federation }}" + state: absent + register: result + +- name: Assert user federation unchanged + ansible.builtin.assert: + that: + - result is not changed + - result.existing == {} + - result.end_state == {} + +- name: Create new user federation together with mappers + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ ephemeral_realm }}" + name: "{{ federation }}" + state: present + provider_id: ldap + provider_type: org.keycloak.storage.UserStorageProvider + config: + enabled: true + priority: 0 + fullSyncPeriod: -1 + changedSyncPeriod: -1 + cachePolicy: DEFAULT + batchSizeForSync: 1000 + editMode: READ_ONLY + importEnabled: true + syncRegistrations: false + vendor: other + usernameLDAPAttribute: uid + rdnLDAPAttribute: uid + uuidLDAPAttribute: entryUUID + userObjectClasses: "inetOrgPerson, organizationalPerson" + connectionUrl: "ldaps://ldap.example.com:636" + usersDn: "ou=Users,dc=example,dc=com" + authType: simple + bindDn: cn=directory reader + bindCredential: secret + searchScope: 1 + validatePasswordPolicy: false + trustEmail: false + useTruststoreSpi: "ldapsOnly" + connectionPooling: true + pagination: true + allowKerberosAuthentication: false + useKerberosForPasswordAuthentication: false + debug: false + mappers: + - name: "username" + providerId: "user-attribute-ldap-mapper" + config: + ldap.attribute: ldap_user + user.model.attribute: usr + read.only: true + - name: "full name" + providerId: "full-name-ldap-mapper" + providerType: "org.keycloak.storage.ldap.mappers.LDAPStorageMapper" + config: + ldap.full.name.attribute: cn + read.only: true + write.only: false + register: result + +- name: Assert user federation created + ansible.builtin.assert: + that: + - result is changed + - result.existing == {} + - result.end_state.name == federation + +- name: Clean up - delete user federation + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ ephemeral_realm }}" + name: "{{ federation }}" + state: absent + +- name: Clean up - delete user federation (admin realm) + middleware_automation.keycloak.keycloak_user_federation: + realm: "{{ auth_realm }}" + name: "{{ federation }}" + state: absent diff --git a/molecule/keycloak_modules/keycloak_user_rolemapping/vars.yml b/molecule/keycloak_modules/keycloak_user_rolemapping/vars.yml new file mode 100644 index 0000000..c61a578 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_user_rolemapping/vars.yml @@ -0,0 +1,5 @@ +--- +client_id: myclient +client_id_2: myotherclient +test_role: myrole +description_1: desc 1 diff --git a/molecule/keycloak_modules/keycloak_user_rolemapping/verify.yml b/molecule/keycloak_modules/keycloak_user_rolemapping/verify.yml new file mode 100644 index 0000000..ac1db28 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_user_rolemapping/verify.yml @@ -0,0 +1,141 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_user_rolemapping +# Tests service account role mapping (realm and client roles) and cross-client mapping. + +- name: Load user rolemapping test variables + ansible.builtin.include_vars: + file: vars.yml + +- name: Create client with service account for rolemapping test + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + service_accounts_enabled: true + state: present + register: rolemapping_client + +- name: Create realm role for service account mapping + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: "{{ test_role }}" + description: "{{ description_1 }}" + state: present + +- name: Map realm role to client service account + middleware_automation.keycloak.keycloak_user_rolemapping: + realm: "{{ ephemeral_realm }}" + service_account_user_client_id: "{{ client_id }}" + roles: + - name: "{{ test_role }}" + state: present + register: result + +- name: Assert realm role is assigned to service account + ansible.builtin.assert: + that: + - result is changed + - result.end_state | selectattr("clientRole", "eq", false) | selectattr("name", "eq", test_role) | list | count > 0 + +- name: Unmap realm role from client service account + middleware_automation.keycloak.keycloak_user_rolemapping: + realm: "{{ ephemeral_realm }}" + service_account_user_client_id: "{{ client_id }}" + roles: + - name: "{{ test_role }}" + state: absent + register: result + +- name: Assert realm role is unassigned from service account + ansible.builtin.assert: + that: + - result is changed + - (result.end_state | length) == (result.existing | length) - 1 + - result.existing | selectattr("clientRole", "eq", false) | selectattr("name", "eq", test_role) | list | count > 0 + - result.end_state | selectattr("clientRole", "eq", false) | selectattr("name", "eq", test_role) | list | count == 0 + +- name: Delete existing realm role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + name: "{{ test_role }}" + state: absent + +- name: Create second client for cross-client role mapping test + middleware_automation.keycloak.keycloak_client: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id_2 }}" + service_accounts_enabled: true + state: present + register: client_2 + +- name: Create new client role + middleware_automation.keycloak.keycloak_role: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + name: "{{ test_role }}" + description: "{{ description_1 }}" + state: present + +- name: Map client role to user with no existing roles for that client + middleware_automation.keycloak.keycloak_user_rolemapping: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + service_account_user_client_id: "{{ client_id_2 }}" + roles: + - name: "{{ test_role }}" + state: present + register: result + +- name: Assert client role is assigned to user with no prior roles + ansible.builtin.assert: + that: + - result is changed + - result.end_state | selectattr("clientRole", "eq", true) | selectattr("name", "eq", test_role) | list | count > 0 + +- name: Unmap the cross-client role mapping + middleware_automation.keycloak.keycloak_user_rolemapping: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + service_account_user_client_id: "{{ client_id_2 }}" + roles: + - name: "{{ test_role }}" + state: absent + register: result + +- name: Assert cross-client role mapping is removed + ansible.builtin.assert: + that: + - result is changed + - result.end_state == [] + +- name: Map client role to client service account + middleware_automation.keycloak.keycloak_user_rolemapping: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + service_account_user_client_id: "{{ client_id }}" + roles: + - name: "{{ test_role }}" + state: present + register: result + +- name: Assert client role is assigned + ansible.builtin.assert: + that: + - result is changed + - result.end_state | selectattr("clientRole", "eq", true) | selectattr("name", "eq", test_role) | list | count > 0 + +- name: Unmap client role from client service account + middleware_automation.keycloak.keycloak_user_rolemapping: + realm: "{{ ephemeral_realm }}" + client_id: "{{ client_id }}" + service_account_user_client_id: "{{ client_id }}" + roles: + - name: "{{ test_role }}" + state: absent + register: result + +- name: Assert client role is unassigned + ansible.builtin.assert: + that: + - result is changed + - result.end_state == [] + - result.existing | selectattr("clientRole", "eq", true) | selectattr("name", "eq", test_role) | list | count > 0 diff --git a/molecule/keycloak_modules/keycloak_userprofile/vars.yml b/molecule/keycloak_modules/keycloak_userprofile/vars.yml new file mode 100644 index 0000000..d598333 --- /dev/null +++ b/molecule/keycloak_modules/keycloak_userprofile/vars.yml @@ -0,0 +1,109 @@ +--- +attributes_default: + - name: username + displayName: "${username}" + validations: + length: + min: 3 + max: 255 + usernameProhibitedCharacters: {} + up_username_not_idn_homograph: {} + annotations: {} + permissions: + view: + - admin + - user + edit: [] + multivalued: false + - name: email + displayName: "${email}" + validations: + email: {} + length: + max: 255 + annotations: {} + required: + roles: + - user + permissions: + view: + - admin + - user + edit: [] + multivalued: false + - name: firstName + displayName: "${firstName}" + validations: + length: + max: 255 + personNameProhibitedCharacters: {} + annotations: {} + required: + roles: + - user + permissions: + view: + - admin + - user + edit: [] + multivalued: false + - name: lastName + displayName: "${lastName}" + validations: + length: + max: 255 + person_name_prohibited_characters: {} + annotations: {} + required: + roles: + - user + permissions: + view: + - admin + - user + edit: [] + multivalued: false + +attributes_additional: + - name: additionalAttribute + displayName: additionalAttribute + group: user-metadata + required: + roles: + - user + permissions: + view: + - admin + - user + edit: [] + multivalued: false + +groups_default: + - name: user-metadata + displayHeader: User metadata + displayDescription: Attributes, which refer to user metadata + +config_default: + kc_user_profile_config: + - attributes: "{{ attributes_default }}" + groups: "{{ groups_default }}" + +config_updated: + kc_user_profile_config: + - attributes: "{{ attributes_default + attributes_additional }}" + groups: "{{ groups_default }}" + +config_unmanaged_attributes_enabled: + kc_user_profile_config: + - unmanagedAttributePolicy: ENABLED + attributes: "{{ attributes_default }}" + +config_unmanaged_attributes_admin_edit: + kc_user_profile_config: + - unmanagedAttributePolicy: ADMIN_EDIT + attributes: "{{ attributes_default }}" + +config_unmanaged_attributes_admin_view: + kc_user_profile_config: + - unmanagedAttributePolicy: ADMIN_VIEW + attributes: "{{ attributes_default }}" diff --git a/molecule/keycloak_modules/keycloak_userprofile/verify.yml b/molecule/keycloak_modules/keycloak_userprofile/verify.yml new file mode 100644 index 0000000..11c8bdb --- /dev/null +++ b/molecule/keycloak_modules/keycloak_userprofile/verify.yml @@ -0,0 +1,187 @@ +--- +# Ported from community.general tests/integration/targets/keycloak_userprofile +# Tests full CRUD cycle with check_mode for user profile config, +# switching between unmanaged attribute policies (ENABLED, ADMIN_EDIT, ADMIN_VIEW). + +- name: Load user profile config variables + ansible.builtin.include_vars: + file: vars.yml + +- name: Create default User Profile (check mode) + middleware_automation.keycloak.keycloak_userprofile: + parent_id: "{{ ephemeral_realm }}" + config: "{{ config_default }}" + check_mode: true + register: result + +- name: Assert User Profile would be created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.providerId == "declarative-user-profile" + - result.end_state.providerType == "org.keycloak.userprofile.UserProfileProvider" + - result.msg == "Userprofile declarative-user-profile would be created" + +- name: Create default User Profile + middleware_automation.keycloak.keycloak_userprofile: + state: present + parent_id: "{{ ephemeral_realm }}" + config: "{{ config_default }}" + diff: true + register: result + +- name: Assert User Profile was created + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.providerId == "declarative-user-profile" + - result.end_state.providerType == "org.keycloak.userprofile.UserProfileProvider" + - result.msg == "Userprofile declarative-user-profile created" + +- name: Create default User Profile (idempotency) + middleware_automation.keycloak.keycloak_userprofile: + state: present + parent_id: "{{ ephemeral_realm }}" + config: "{{ config_default }}" + register: result + +- name: Assert User Profile was in sync + ansible.builtin.assert: + that: + - result is not changed + - result.end_state != {} + - result.end_state.providerId == "declarative-user-profile" + - result.end_state.providerType == "org.keycloak.userprofile.UserProfileProvider" + - result.msg == "Userprofile declarative-user-profile was in sync" + +- name: Update User Profile (check mode) + middleware_automation.keycloak.keycloak_userprofile: + state: present + parent_id: "{{ ephemeral_realm }}" + config: "{{ config_updated }}" + check_mode: true + register: result + +- name: Assert User Profile would be changed + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.providerId == "declarative-user-profile" + - result.end_state.providerType == "org.keycloak.userprofile.UserProfileProvider" + - result.msg.startswith("Userprofile declarative-user-profile would be changed:") + +- name: Update User Profile + middleware_automation.keycloak.keycloak_userprofile: + state: present + parent_id: "{{ ephemeral_realm }}" + config: "{{ config_updated }}" + diff: true + register: result + +- name: Assert User Profile changed + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.providerId == "declarative-user-profile" + - result.end_state.providerType == "org.keycloak.userprofile.UserProfileProvider" + - result.msg.startswith("Userprofile declarative-user-profile changed:") + +- name: Update User Profile (idempotency) + middleware_automation.keycloak.keycloak_userprofile: + state: present + parent_id: "{{ ephemeral_realm }}" + config: "{{ config_updated }}" + register: result + +- name: Assert User Profile still in sync + ansible.builtin.assert: + that: + - result is not changed + - result.end_state != {} + - result.end_state.providerId == "declarative-user-profile" + - result.end_state.providerType == "org.keycloak.userprofile.UserProfileProvider" + - result.msg == "Userprofile declarative-user-profile was in sync" + +- name: Remove User Profile + middleware_automation.keycloak.keycloak_userprofile: + state: absent + parent_id: "{{ ephemeral_realm }}" + config: "{{ config_default }}" + diff: true + register: result + +- name: Assert User Profile was deleted + ansible.builtin.assert: + that: + - result is changed + - result.end_state == {} + - result.msg == "Userprofile declarative-user-profile deleted" + +- name: Remove User Profile (idempotency) + middleware_automation.keycloak.keycloak_userprofile: + state: absent + parent_id: "{{ ephemeral_realm }}" + config: "{{ config_default }}" + register: result + +- name: Assert User Profile not present + ansible.builtin.assert: + that: + - result is not changed + - result.end_state == {} + - result.msg == "Userprofile declarative-user-profile not present" + +- name: Create User Profile with unmanaged attributes ENABLED + middleware_automation.keycloak.keycloak_userprofile: + state: present + parent_id: "{{ ephemeral_realm }}" + config: "{{ config_unmanaged_attributes_enabled }}" + diff: true + register: result + +- name: Assert User Profile created with ENABLED policy + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.providerId == "declarative-user-profile" + - result.end_state.providerType == "org.keycloak.userprofile.UserProfileProvider" + - result.msg == "Userprofile declarative-user-profile created" + +- name: Change User Profile to unmanaged ADMIN_EDIT + middleware_automation.keycloak.keycloak_userprofile: + state: present + parent_id: "{{ ephemeral_realm }}" + config: "{{ config_unmanaged_attributes_admin_edit }}" + diff: true + register: result + +- name: Assert User Profile changed to ADMIN_EDIT + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.providerId == "declarative-user-profile" + - result.end_state.providerType == "org.keycloak.userprofile.UserProfileProvider" + - result.msg.startswith("Userprofile declarative-user-profile changed:") + +- name: Change User Profile to unmanaged ADMIN_VIEW + middleware_automation.keycloak.keycloak_userprofile: + state: present + parent_id: "{{ ephemeral_realm }}" + config: "{{ config_unmanaged_attributes_admin_view }}" + diff: true + register: result + +- name: Assert User Profile changed to ADMIN_VIEW + ansible.builtin.assert: + that: + - result is changed + - result.end_state != {} + - result.end_state.providerId == "declarative-user-profile" + - result.end_state.providerType == "org.keycloak.userprofile.UserProfileProvider" + - result.msg.startswith("Userprofile declarative-user-profile changed:") diff --git a/molecule/keycloak_modules/verify.yml b/molecule/keycloak_modules/verify.yml index 4d78b25..82f948c 100644 --- a/molecule/keycloak_modules/verify.yml +++ b/molecule/keycloak_modules/verify.yml @@ -103,13 +103,13 @@ state: absent failed_when: false - - name: keycloak_role — create realm role for module tests + - name: keycloak_role - create realm role for module tests middleware_automation.keycloak.keycloak_role: realm: "{{ target_realm }}" name: "{{ role }}" state: present - - name: keycloak_client — create confidential client for module tests + - name: keycloak_client - create confidential client for module tests middleware_automation.keycloak.keycloak_client: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -121,7 +121,7 @@ secret: molecule-client-secret state: present - - name: keycloak_client — enable authorization services on test client + - name: keycloak_client - enable authorization services on test client middleware_automation.keycloak.keycloak_client: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -130,26 +130,26 @@ full_scope_allowed: false state: present - - name: keycloak_role — create client role for rolemapping tests + - name: keycloak_role - create client role for rolemapping tests middleware_automation.keycloak.keycloak_role: realm: "{{ target_realm }}" client_id: "{{ client }}" name: "{{ client_role }}" state: present - - name: keycloak_client_scope — create client scope + - name: keycloak_client_scope - create client scope middleware_automation.keycloak.keycloak_client_scope: realm: "{{ target_realm }}" name: "{{ scope }}" state: present - - name: keycloak_group — create group + - name: keycloak_group - create group middleware_automation.keycloak.keycloak_group: realm: "{{ target_realm }}" name: "{{ group }}" state: present - - name: keycloak_user — create user + - name: keycloak_user - create user middleware_automation.keycloak.keycloak_user: realm: "{{ target_realm }}" username: "{{ user }}" @@ -159,13 +159,13 @@ enabled: true state: present - - name: keycloak_role — create realm role for restricted admin test + - name: keycloak_role - create realm role for restricted admin test middleware_automation.keycloak.keycloak_role: realm: "{{ target_realm }}" name: "{{ role }}-restricted" state: present - - name: keycloak_user — create restricted admin in master (manage-users only, no view-realm) + - name: keycloak_user - create restricted admin in master (manage-users only, no view-realm) middleware_automation.keycloak.keycloak_user: realm: master username: molecule-restricted-admin @@ -178,7 +178,7 @@ temporary: false state: present - - name: keycloak_user_rolemapping — grant manage-users for TestRealm to restricted admin + - name: keycloak_user_rolemapping - grant manage-users for TestRealm to restricted admin middleware_automation.keycloak.keycloak_user_rolemapping: realm: master target_username: molecule-restricted-admin @@ -188,7 +188,7 @@ - name: manage-users - name: view-users - - name: keycloak_authentication_flow — create browser-style flow + - name: keycloak_authentication_flow - create browser-style flow middleware_automation.keycloak.keycloak_authentication_flow: realm: "{{ target_realm }}" alias: "{{ flow }}" @@ -198,7 +198,7 @@ requirement: REQUIRED state: present - - name: keycloak_realm_info — query TestRealm (public endpoint, no admin auth) + - name: keycloak_realm_info - query TestRealm (public endpoint, no admin auth) middleware_automation.keycloak.keycloak_realm_info: auth_keycloak_url: "{{ auth_keycloak_url }}" realm: "{{ target_realm }}" @@ -213,15 +213,15 @@ auth_password: "{{ auth_password }}" validate_certs: false block: - - name: keycloak_realm_keys_metadata_info — query realm keys + - name: keycloak_realm_keys_metadata_info - query realm keys middleware_automation.keycloak.keycloak_realm_keys_metadata_info: realm: "{{ target_realm }}" - - name: keycloak_component_info — list realm components + - name: keycloak_component_info - list realm components middleware_automation.keycloak.keycloak_component_info: realm: "{{ target_realm }}" - - name: keycloak_realm_users_info — list users in realm + - name: keycloak_realm_users_info - list users in realm middleware_automation.keycloak.keycloak_realm_users_info: realm: "{{ target_realm }}" register: realm_users_info_result @@ -233,14 +233,14 @@ - realm_users_info_result.users | length > 0 - realm_users_info_result.users | selectattr('username', 'equalto', user) | list | length == 1 - - name: keycloak_realm — create ephemeral realm + - name: keycloak_realm - create ephemeral realm middleware_automation.keycloak.keycloak_realm: id: "{{ ephemeral_realm }}" realm: "{{ ephemeral_realm }}" enabled: true state: present - - name: keycloak_realm — modify realm attributes without pruning undefined attributes. Step 1 - Introduce custom realm attributes + - name: keycloak_realm - modify realm attributes without pruning undefined attributes. Step 1 - Introduce custom realm attributes middleware_automation.keycloak.keycloak_realm: id: "{{ ephemeral_realm }}" realm: "{{ ephemeral_realm }}" @@ -259,7 +259,7 @@ - custom_realm_attributes_result.end_state.attributes["custom-realm-attribute-1"] == "123" - custom_realm_attributes_result.end_state.attributes["custom-realm-attribute-2"] == "true" - - name: keycloak_realm — modify realm attributes without pruning undefined attributes. Step 2 - Verify unchanged custom realm attributes + - name: keycloak_realm - modify realm attributes without pruning undefined attributes. Step 2 - Verify unchanged custom realm attributes middleware_automation.keycloak.keycloak_realm: id: "{{ ephemeral_realm }}" realm: "{{ ephemeral_realm }}" @@ -277,7 +277,7 @@ - custom_realm_attributes_result.end_state.attributes["custom-realm-attribute-1"] == "123" # should still be 123 - custom_realm_attributes_result.end_state.attributes["custom-realm-attribute-2"] == "false" - - name: keycloak_realm — modify realm attributes with pruning undefined attributes + - name: keycloak_realm - modify realm attributes with pruning undefined attributes middleware_automation.keycloak.keycloak_realm: id: "{{ ephemeral_realm }}" realm: "{{ ephemeral_realm }}" @@ -296,16 +296,84 @@ - custom_realm_attributes_result.end_state.attributes["custom-realm-attribute-2"] is not defined - custom_realm_attributes_result.end_state.attributes["custom-realm-attribute-3"] == "custom-attribute-3" + - name: keycloak_realm - session timeout and OAuth2 device settings + ansible.builtin.include_tasks: + file: keycloak_realm/verify.yml + + - name: keycloak_group_rolemapping - full map/unmap lifecycle + ansible.builtin.include_tasks: + file: keycloak_group_rolemapping/verify.yml + + - name: keycloak_client_scope_type - realm and client scope types + ansible.builtin.include_tasks: + file: keycloak_client_scope_type/verify.yml + + - name: keycloak_realm_users_info - multi-user and group membership + ansible.builtin.include_tasks: + file: keycloak_realm_users_info/verify.yml + + - name: keycloak_user_rolemapping - service account role mapping + ansible.builtin.include_tasks: + file: keycloak_user_rolemapping/verify.yml + + - name: keycloak_role - full CRUD and composite roles + ansible.builtin.include_tasks: + file: keycloak_role/verify.yml + + - name: keycloak_user - edge cases (plus-addressed email, groups, required_actions reset) + ansible.builtin.include_tasks: + file: keycloak_user/verify.yml + + - name: keycloak_identity_provider - mapper CRUD and fromUrl discovery + ansible.builtin.include_tasks: + file: keycloak_identity_provider/verify.yml + + - name: keycloak_client_rolescope - multi-role and error cases + ansible.builtin.include_tasks: + file: keycloak_client_rolescope/verify.yml + + - name: keycloak_client_scope_rolemappings - error paths, check_mode, multi-role + ansible.builtin.include_tasks: + file: keycloak_client_scope_rolemappings/verify.yml + + - name: keycloak_user_federation - full LDAP federation lifecycle + ansible.builtin.include_tasks: + file: keycloak_user_federation/verify.yml + + - name: keycloak_component_info - query patterns (name, type, parent, subcomponents) + ansible.builtin.include_tasks: + file: keycloak_component_info/verify.yml + + - name: keycloak_realm_key - auto-generated key providers (7 types) + ansible.builtin.include_tasks: + file: keycloak_realm_key/verify.yml + + - name: keycloak_userprofile - full CRUD with check_mode + ansible.builtin.include_tasks: + file: keycloak_userprofile/verify.yml + + - name: keycloak_client - flow bindings, scopes behavior, attributes + ansible.builtin.include_tasks: + file: keycloak_client/verify.yml + + - name: keycloak_group - deep subgroups, attributes, rename, cascade delete + ansible.builtin.include_tasks: + file: keycloak_group/verify.yml + + - name: keycloak_authentication - conditional OTP flow CRUD and config uniqueness + ansible.builtin.include_tasks: + file: keycloak_authentication/verify.yml + # --- Organization module tests --- - - name: keycloak_realm — enable organizations on ephemeral realm + - name: keycloak_realm - enable organizations on ephemeral realm middleware_automation.keycloak.keycloak_realm: id: "{{ ephemeral_realm }}" realm: "{{ ephemeral_realm }}" organizations_enabled: true state: present - - name: keycloak_organization — create organization + - name: keycloak_organization - create organization middleware_automation.keycloak.keycloak_organization: realm: "{{ ephemeral_realm }}" name: molecule-org @@ -325,7 +393,7 @@ - org_create_result.end_state.enabled == true - org_create_result.end_state.id is defined - - name: keycloak_organization — create organization (idempotency) + - name: keycloak_organization - create organization (idempotency) middleware_automation.keycloak.keycloak_organization: realm: "{{ ephemeral_realm }}" name: molecule-org @@ -341,7 +409,7 @@ that: - org_create_idempotent_result is not changed - - name: keycloak_organization — update organization description + - name: keycloak_organization - update organization description middleware_automation.keycloak.keycloak_organization: realm: "{{ ephemeral_realm }}" name: molecule-org @@ -355,7 +423,7 @@ - org_update_result is changed - org_update_result.end_state.description == "Updated molecule test organization" - - name: keycloak_organization — update organization (idempotency) + - name: keycloak_organization - update organization (idempotency) middleware_automation.keycloak.keycloak_organization: realm: "{{ ephemeral_realm }}" name: molecule-org @@ -368,7 +436,7 @@ that: - org_update_idempotent_result is not changed - - name: keycloak_organization_info — query organization by name + - name: keycloak_organization_info - query organization by name middleware_automation.keycloak.keycloak_organization_info: realm: "{{ ephemeral_realm }}" name: molecule-org @@ -381,7 +449,7 @@ - org_info_result.organizations | length == 1 - org_info_result.organizations[0].name == "molecule-org" - - name: keycloak_organization_info — list all organizations + - name: keycloak_organization_info - list all organizations middleware_automation.keycloak.keycloak_organization_info: realm: "{{ ephemeral_realm }}" register: org_info_all_result @@ -391,7 +459,7 @@ that: - org_info_all_result.organizations | length >= 1 - - name: keycloak_organization — create organization with attributes + - name: keycloak_organization - create organization with attributes middleware_automation.keycloak.keycloak_organization: realm: "{{ ephemeral_realm }}" name: molecule-org-attrs @@ -411,7 +479,7 @@ - org_attrs_result.end_state.attributes.department == ["engineering"] - org_attrs_result.end_state.attributes.tags == ["test", "molecule"] - - name: keycloak_organization — delete organization with attributes + - name: keycloak_organization - delete organization with attributes middleware_automation.keycloak.keycloak_organization: realm: "{{ ephemeral_realm }}" name: molecule-org-attrs @@ -423,7 +491,7 @@ that: - org_attrs_delete_result is changed - - name: keycloak_organization — delete organization + - name: keycloak_organization - delete organization middleware_automation.keycloak.keycloak_organization: realm: "{{ ephemeral_realm }}" name: molecule-org @@ -435,7 +503,7 @@ that: - org_delete_result is changed - - name: keycloak_organization — delete organization (idempotency) + - name: keycloak_organization - delete organization (idempotency) middleware_automation.keycloak.keycloak_organization: realm: "{{ ephemeral_realm }}" name: molecule-org @@ -447,7 +515,7 @@ that: - org_delete_idempotent_result is not changed - - name: keycloak_realm_localization — set locale override + - name: keycloak_realm_localization - set locale override middleware_automation.keycloak.keycloak_realm_localization: parent_id: "{{ target_realm }}" locale: en @@ -456,25 +524,25 @@ - key: molecule.module.test value: molecule module test - - name: keycloak_realm_key — create generated AES key component + - name: keycloak_realm_key - create generated AES key component middleware_automation.keycloak.keycloak_realm_key: parent_id: "{{ target_realm }}" name: "{{ realm_key }}" provider_id: aes-generated state: present - - name: keycloak_authentication — copy browser flow + - name: keycloak_authentication - copy browser flow middleware_automation.keycloak.keycloak_authentication: realm: "{{ target_realm }}" alias: "{{ auth_copy }}" copyFrom: browser state: present - - name: keycloak_authentication_v2 — manage flow with safe-swap semantics + - name: keycloak_authentication_v2 - manage flow with safe-swap semantics ansible.builtin.include_tasks: file: keycloak_authentication_v2/verify.yml - - name: keycloak_authentication_required_actions — ensure VERIFY_EMAIL is enabled + - name: keycloak_authentication_required_actions - ensure VERIFY_EMAIL is enabled middleware_automation.keycloak.keycloak_authentication_required_actions: realm: "{{ target_realm }}" state: present @@ -482,7 +550,7 @@ - alias: VERIFY_EMAIL enabled: true - - name: keycloak_userprofile — set unmanaged attribute policy + - name: keycloak_userprofile - set unmanaged attribute policy middleware_automation.keycloak.keycloak_userprofile: parent_id: "{{ target_realm }}" state: present @@ -490,7 +558,7 @@ kc_user_profile_config: - unmanagedAttributePolicy: ENABLED - - name: keycloak_identity_provider — create OIDC broker stub + - name: keycloak_identity_provider - create OIDC broker stub middleware_automation.keycloak.keycloak_identity_provider: realm: "{{ target_realm }}" alias: "{{ idp }}" @@ -502,7 +570,7 @@ clientId: molecule-idp-client state: present - - name: keycloak_identity_provider — set hide_on_login via top-level param + - name: keycloak_identity_provider - set hide_on_login via top-level param middleware_automation.keycloak.keycloak_identity_provider: realm: "{{ target_realm }}" alias: "{{ idp }}" @@ -517,7 +585,7 @@ - idp_hide_on_login_result.end_state.hideOnLogin == true - "'hide_on_login' not in (idp_hide_on_login_result.end_state.config | default({}))" - - name: keycloak_identity_provider — set hide_on_login idempotency check + - name: keycloak_identity_provider - set hide_on_login idempotency check middleware_automation.keycloak.keycloak_identity_provider: realm: "{{ target_realm }}" alias: "{{ idp }}" @@ -531,7 +599,7 @@ - idp_hide_on_login_idempotent_result is not changed - idp_hide_on_login_idempotent_result.end_state.hideOnLogin == true - - name: keycloak_identity_provider — set hide_on_login via legacy config key (backward compat) + - name: keycloak_identity_provider - set hide_on_login via legacy config key (backward compat) middleware_automation.keycloak.keycloak_identity_provider: realm: "{{ target_realm }}" alias: "{{ idp }}" @@ -546,7 +614,7 @@ - idp_hide_on_login_off_result.end_state.hideOnLogin == false - "'hide_on_login_page' not in (idp_hide_on_login_off_result.end_state.config | default({}))" - - name: keycloak_identity_provider — set doNotStoreUsers config option + - name: keycloak_identity_provider - set doNotStoreUsers config option middleware_automation.keycloak.keycloak_identity_provider: realm: "{{ target_realm }}" alias: "{{ idp }}" @@ -561,7 +629,7 @@ - idp_do_not_store_users_result is changed - idp_do_not_store_users_result.end_state.config.doNotStoreUsers == "true" - - name: keycloak_identity_provider — set doNotStoreUsers idempotency check + - name: keycloak_identity_provider - set doNotStoreUsers idempotency check middleware_automation.keycloak.keycloak_identity_provider: realm: "{{ target_realm }}" alias: "{{ idp }}" @@ -576,7 +644,7 @@ - idp_do_not_store_users_idempotent_result is not changed - idp_do_not_store_users_idempotent_result.end_state.config.doNotStoreUsers == "true" - - name: keycloak_identity_provider — disable doNotStoreUsers + - name: keycloak_identity_provider - disable doNotStoreUsers middleware_automation.keycloak.keycloak_identity_provider: realm: "{{ target_realm }}" alias: "{{ idp }}" @@ -591,7 +659,7 @@ - idp_do_not_store_users_off_result is changed - idp_do_not_store_users_off_result.end_state.config.doNotStoreUsers == "false" - - name: keycloak_clienttemplate — create client template + - name: keycloak_clienttemplate - create client template middleware_automation.keycloak.keycloak_clienttemplate: realm: "{{ target_realm }}" name: "{{ template }}" @@ -603,13 +671,13 @@ - "'404' not in (clienttemplate_result.msg | default(''))" - "'Not Found' not in (clienttemplate_result.msg | default(''))" - - name: keycloak_client_scope_type — attach scope as optional on realm + - name: keycloak_client_scope_type - attach scope as optional on realm middleware_automation.keycloak.keycloak_client_scope_type: realm: "{{ target_realm }}" optional_client_scopes: - "{{ scope }}" - - name: keycloak_user_rolemapping — assign realm role to user + - name: keycloak_user_rolemapping - assign realm role to user middleware_automation.keycloak.keycloak_user_rolemapping: realm: "{{ target_realm }}" target_username: "{{ user }}" @@ -617,7 +685,7 @@ roles: - name: "{{ role }}" - - name: keycloak_user_rolemapping — assign realm role using restricted admin (no view-realm) + - name: keycloak_user_rolemapping - assign realm role using restricted admin (no view-realm) middleware_automation.keycloak.keycloak_user_rolemapping: auth_keycloak_url: "{{ auth_keycloak_url }}" auth_realm: master @@ -636,7 +704,7 @@ that: - restricted_admin_rolemapping_result is changed - - name: keycloak_user_rolemapping — idempotency check with restricted admin + - name: keycloak_user_rolemapping - idempotency check with restricted admin middleware_automation.keycloak.keycloak_user_rolemapping: auth_keycloak_url: "{{ auth_keycloak_url }}" auth_realm: master @@ -655,7 +723,7 @@ that: - restricted_admin_rolemapping_idempotent_result is not changed - - name: keycloak_realm_rolemapping — assign realm role to group + - name: keycloak_realm_rolemapping - assign realm role to group middleware_automation.keycloak.keycloak_realm_rolemapping: realm: "{{ target_realm }}" group_name: "{{ group }}" @@ -663,7 +731,7 @@ roles: - name: "{{ role }}" - - name: keycloak_client_rolemapping — assign client role to group + - name: keycloak_client_rolemapping - assign client role to group middleware_automation.keycloak.keycloak_client_rolemapping: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -672,7 +740,7 @@ roles: - name: "{{ client_role }}" - - name: keycloak_group — create subgroup below the parent group + - name: keycloak_group - create subgroup below the parent group middleware_automation.keycloak.keycloak_group: realm: "{{ target_realm }}" name: "{{ subgroup }}" @@ -687,7 +755,7 @@ - subgroup_result is changed - subgroup_result.end_state.path == '/' ~ group ~ '/' ~ subgroup - - name: keycloak_group — create enough siblings to exceed the children page size + - name: keycloak_group - create enough siblings to exceed the children page size middleware_automation.keycloak.keycloak_group: realm: "{{ target_realm }}" name: "{{ subgroup }}-{{ item }}" @@ -696,7 +764,7 @@ state: present loop: "{{ range(1, 13) | list }}" - - name: keycloak_group — look up a subgroup sorting past the children page size + - name: keycloak_group - look up a subgroup sorting past the children page size middleware_automation.keycloak.keycloak_group: realm: "{{ target_realm }}" name: "{{ subgroup }}-9" @@ -711,7 +779,7 @@ - subgroup_paging_result is not changed - subgroup_paging_result.end_state.path == '/' ~ group ~ '/' ~ subgroup ~ '-9' - - name: keycloak_realm_rolemapping — assign realm role to subgroup via parents + - name: keycloak_realm_rolemapping - assign realm role to subgroup via parents middleware_automation.keycloak.keycloak_realm_rolemapping: realm: "{{ target_realm }}" group_name: "{{ subgroup }}" @@ -727,7 +795,7 @@ that: - subgroup_rolemapping_result is changed - - name: keycloak_client_rolescope — restrict realm role on client + - name: keycloak_client_rolescope - restrict realm role on client middleware_automation.keycloak.keycloak_client_rolescope: realm: "{{ target_realm }}" target_client_id: "{{ client }}" @@ -735,7 +803,7 @@ - "{{ role }}" state: present - - name: keycloak_client_scope_rolemappings — map client roles to client scope + - name: keycloak_client_scope_rolemappings - map client roles to client scope middleware_automation.keycloak.keycloak_client_scope_rolemappings: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -750,7 +818,7 @@ - client_scope_rolemappings_result is changed - client_scope_rolemappings_result.end_state | length == 1 - - name: keycloak_client_scope_rolemappings — remap client role (idempotency) + - name: keycloak_client_scope_rolemappings - remap client role (idempotency) middleware_automation.keycloak.keycloak_client_scope_rolemappings: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -765,7 +833,7 @@ - client_scope_rolemappings_idempotent_result is not changed - client_scope_rolemappings_idempotent_result.end_state | length == 1 - - name: keycloak_client_scope_rolemappings — map realm role to client scope + - name: keycloak_client_scope_rolemappings - map realm role to client scope middleware_automation.keycloak.keycloak_client_scope_rolemappings: realm: "{{ target_realm }}" client_scope_id: "{{ scope }}" @@ -779,7 +847,7 @@ - client_scope_realm_rolemappings_result is changed - client_scope_realm_rolemappings_result.end_state | length == 1 - - name: keycloak_user — set email_verified explicitly + - name: keycloak_user - set email_verified explicitly middleware_automation.keycloak.keycloak_user: realm: "{{ target_realm }}" username: "{{ user }}" @@ -793,7 +861,7 @@ - user_email_verified_result is changed - user_email_verified_result.end_state.emailVerified == true - - name: keycloak_user — leave email_verified unchanged with no_defaults + - name: keycloak_user - leave email_verified unchanged with no_defaults middleware_automation.keycloak.keycloak_user: realm: "{{ target_realm }}" username: "{{ user }}" @@ -807,7 +875,7 @@ - user_email_verified_idempotent_result is not changed - user_email_verified_idempotent_result.end_state.emailVerified == true - - name: keycloak_user — set required actions + - name: keycloak_user - set required actions middleware_automation.keycloak.keycloak_user: realm: "{{ target_realm }}" username: "{{ user }}" @@ -824,7 +892,7 @@ - "'UPDATE_PASSWORD' in user_required_actions_result.end_state.requiredActions" - "'VERIFY_EMAIL' in user_required_actions_result.end_state.requiredActions" - - name: keycloak_user — leave required actions unchanged when omitted + - name: keycloak_user - leave required actions unchanged when omitted middleware_automation.keycloak.keycloak_user: realm: "{{ target_realm }}" username: "{{ user }}" @@ -838,19 +906,35 @@ - "'UPDATE_PASSWORD' in user_required_actions_idempotent_result.end_state.requiredActions" - "'VERIFY_EMAIL' in user_required_actions_idempotent_result.end_state.requiredActions" - - name: keycloak_clientsecret_info — read client secret + - name: keycloak_clientsecret_info - read client secret middleware_automation.keycloak.keycloak_clientsecret_info: realm: "{{ target_realm }}" client_id: "{{ client }}" no_log: true - - name: keycloak_clientsecret_regenerate — rotate client secret + - name: keycloak_clientsecret_regenerate - rotate client secret middleware_automation.keycloak.keycloak_clientsecret_regenerate: realm: "{{ target_realm }}" client_id: "{{ client }}" no_log: true - - name: keycloak_authz_authorization_scope — create authorization scope + - name: keycloak_clientsecret_info - fetch by client_id and by id + ansible.builtin.include_tasks: + file: keycloak_clientsecret_info/verify.yml + + - name: keycloak_clientsecret_regenerate - rotation contract and by-id + ansible.builtin.include_tasks: + file: keycloak_clientsecret_regenerate/verify.yml + + - name: keycloak_authz_authorization_scope - full CRUD with check_mode + ansible.builtin.include_tasks: + file: keycloak_authz_authorization_scope/verify.yml + + - name: keycloak_authz_permission - scope and resource permissions lifecycle + ansible.builtin.include_tasks: + file: keycloak_authz_permission/verify.yml + + - name: keycloak_authz_authorization_scope - create authorization scope middleware_automation.keycloak.keycloak_authz_authorization_scope: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -858,7 +942,7 @@ display_name: Molecule module test scope state: present - - name: keycloak_authz_permission — create scope permission + - name: keycloak_authz_permission - create scope permission middleware_automation.keycloak.keycloak_authz_permission: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -868,13 +952,13 @@ - "{{ authz_scope }}" state: present - - name: keycloak_authz_permission_info — query scope permission + - name: keycloak_authz_permission_info - query scope permission middleware_automation.keycloak.keycloak_authz_permission_info: realm: "{{ target_realm }}" client_id: "{{ client }}" name: "{{ authz_permission }}" - - name: keycloak_authz_custom_policy — requires deployed policy provider on server + - name: keycloak_authz_custom_policy - requires deployed policy provider on server middleware_automation.keycloak.keycloak_authz_custom_policy: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -890,7 +974,7 @@ - "'Method Not Allowed' not in (authz_custom_policy_result.msg | default(''))" - "'not found' not in (authz_custom_policy_result.msg | default('') | lower)" - - name: keycloak_user_execute_actions_email — trigger execute-actions email + - name: keycloak_user_execute_actions_email - trigger execute-actions email middleware_automation.keycloak.keycloak_user_execute_actions_email: realm: "{{ target_realm }}" username: "{{ user }}" @@ -902,7 +986,7 @@ - "'Connection refused' in (execute_actions_email_result.msg | default(''))" - "'Failed to send' in (execute_actions_email_result.msg | default(''))" - - name: keycloak_user_federation — create LDAP federation + - name: keycloak_user_federation - create LDAP federation middleware_automation.keycloak.keycloak_user_federation: realm: "{{ target_realm }}" name: "{{ federation }}" @@ -938,7 +1022,7 @@ that: - federation_create_result is changed - - name: keycloak_user_federation — create LDAP federation (idempotency) + - name: keycloak_user_federation - create LDAP federation (idempotency) middleware_automation.keycloak.keycloak_user_federation: realm: "{{ target_realm }}" name: "{{ federation }}" @@ -974,7 +1058,7 @@ that: - federation_idempotent_result is not changed - - name: keycloak_user_federation — check mode reports no change when config matches + - name: keycloak_user_federation - check mode reports no change when config matches middleware_automation.keycloak.keycloak_user_federation: realm: "{{ target_realm }}" name: "{{ federation }}" @@ -1011,7 +1095,7 @@ that: - federation_check_mode_result is not changed - - name: keycloak_user_federation — remove federation + - name: keycloak_user_federation - remove federation middleware_automation.keycloak.keycloak_user_federation: realm: "{{ target_realm }}" name: "{{ federation }}" @@ -1023,13 +1107,13 @@ that: - federation_remove_result is changed - - name: keycloak_user_federation — remove non-existent federation (module API test) + - name: keycloak_user_federation - remove non-existent federation (module API test) middleware_automation.keycloak.keycloak_user_federation: realm: "{{ target_realm }}" name: "{{ federation }}" state: absent - - name: keycloak_component — remove non-existent component (module API test) + - name: keycloak_component - remove non-existent component (module API test) middleware_automation.keycloak.keycloak_component: parent_id: "{{ target_realm }}" name: "{{ component }}" @@ -1037,6 +1121,10 @@ provider_type: org.keycloak.storage.UserStorageProvider state: absent + - name: keycloak_modules_authentication - token, refresh, client_credentials auth + ansible.builtin.include_tasks: + file: keycloak_modules_authentication/verify.yml + - name: Remove shared test fixtures module_defaults: group/middleware_automation.keycloak.keycloak: @@ -1046,7 +1134,7 @@ auth_password: "{{ auth_password }}" validate_certs: false block: - - name: keycloak_authz_custom_policy — remove custom policy if created + - name: keycloak_authz_custom_policy - remove custom policy if created middleware_automation.keycloak.keycloak_authz_custom_policy: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -1055,7 +1143,7 @@ state: absent failed_when: false - - name: keycloak_authz_permission — remove scope permission + - name: keycloak_authz_permission - remove scope permission middleware_automation.keycloak.keycloak_authz_permission: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -1063,14 +1151,14 @@ permission_type: scope state: absent - - name: keycloak_authz_authorization_scope — remove authorization scope + - name: keycloak_authz_authorization_scope - remove authorization scope middleware_automation.keycloak.keycloak_authz_authorization_scope: realm: "{{ target_realm }}" client_id: "{{ client }}" name: "{{ authz_scope }}" state: absent - - name: keycloak_client_scope_rolemappings — remove realm role from client scope + - name: keycloak_client_scope_rolemappings - remove realm role from client scope middleware_automation.keycloak.keycloak_client_scope_rolemappings: realm: "{{ target_realm }}" client_scope_id: "{{ scope }}" @@ -1078,7 +1166,7 @@ - "{{ role }}" state: absent - - name: keycloak_client_scope_rolemappings — remove client role from client scope + - name: keycloak_client_scope_rolemappings - remove client role from client scope middleware_automation.keycloak.keycloak_client_scope_rolemappings: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -1087,7 +1175,7 @@ - "{{ client_role }}" state: absent - - name: keycloak_client_rolescope — remove role scope mapping + - name: keycloak_client_rolescope - remove role scope mapping middleware_automation.keycloak.keycloak_client_rolescope: realm: "{{ target_realm }}" target_client_id: "{{ client }}" @@ -1095,7 +1183,7 @@ - "{{ role }}" state: absent - - name: keycloak_client_rolemapping — remove group client role mapping + - name: keycloak_client_rolemapping - remove group client role mapping middleware_automation.keycloak.keycloak_client_rolemapping: realm: "{{ target_realm }}" client_id: "{{ client }}" @@ -1104,7 +1192,7 @@ roles: - name: "{{ client_role }}" - - name: keycloak_realm_rolemapping — remove group realm role mapping + - name: keycloak_realm_rolemapping - remove group realm role mapping middleware_automation.keycloak.keycloak_realm_rolemapping: realm: "{{ target_realm }}" group_name: "{{ group }}" @@ -1112,7 +1200,7 @@ roles: - name: "{{ role }}" - - name: keycloak_user_rolemapping — remove user role mapping + - name: keycloak_user_rolemapping - remove user role mapping middleware_automation.keycloak.keycloak_user_rolemapping: realm: "{{ target_realm }}" target_username: "{{ user }}" @@ -1120,7 +1208,7 @@ roles: - name: "{{ role }}" - - name: keycloak_user_rolemapping — remove restricted admin role mapping from user + - name: keycloak_user_rolemapping - remove restricted admin role mapping from user middleware_automation.keycloak.keycloak_user_rolemapping: realm: "{{ target_realm }}" target_username: "{{ user }}" @@ -1128,38 +1216,38 @@ roles: - name: "{{ role }}-restricted" - - name: keycloak_user — remove restricted admin user from master + - name: keycloak_user - remove restricted admin user from master middleware_automation.keycloak.keycloak_user: realm: master username: molecule-restricted-admin state: absent - - name: keycloak_role — remove restricted admin test role + - name: keycloak_role - remove restricted admin test role middleware_automation.keycloak.keycloak_role: realm: "{{ target_realm }}" name: "{{ role }}-restricted" state: absent - - name: keycloak_identity_provider — remove OIDC provider + - name: keycloak_identity_provider - remove OIDC provider middleware_automation.keycloak.keycloak_identity_provider: realm: "{{ target_realm }}" alias: "{{ idp }}" state: absent - - name: keycloak_authentication — remove copied flow + - name: keycloak_authentication - remove copied flow middleware_automation.keycloak.keycloak_authentication: realm: "{{ target_realm }}" alias: "{{ auth_copy }}" state: absent - - name: keycloak_realm_key — remove generated key + - name: keycloak_realm_key - remove generated key middleware_automation.keycloak.keycloak_realm_key: parent_id: "{{ target_realm }}" name: "{{ realm_key }}" provider_id: aes-generated state: absent - - name: keycloak_realm_localization — remove locale override + - name: keycloak_realm_localization - remove locale override middleware_automation.keycloak.keycloak_realm_localization: parent_id: "{{ target_realm }}" locale: en @@ -1167,57 +1255,57 @@ overrides: - key: molecule.module.test - - name: keycloak_realm — remove ephemeral realm + - name: keycloak_realm - remove ephemeral realm middleware_automation.keycloak.keycloak_realm: id: "{{ ephemeral_realm }}" realm: "{{ ephemeral_realm }}" state: absent - - name: keycloak_clienttemplate — remove client template + - name: keycloak_clienttemplate - remove client template middleware_automation.keycloak.keycloak_clienttemplate: realm: "{{ target_realm }}" name: "{{ template }}" state: absent failed_when: false - - name: keycloak_authentication_flow — remove authentication flow + - name: keycloak_authentication_flow - remove authentication flow middleware_automation.keycloak.keycloak_authentication_flow: realm: "{{ target_realm }}" alias: "{{ flow }}" state: absent - - name: keycloak_user — remove user + - name: keycloak_user - remove user middleware_automation.keycloak.keycloak_user: realm: "{{ target_realm }}" username: "{{ user }}" state: absent - - name: keycloak_group — remove group + - name: keycloak_group - remove group middleware_automation.keycloak.keycloak_group: realm: "{{ target_realm }}" name: "{{ group }}" state: absent - - name: keycloak_role — remove client role + - name: keycloak_role - remove client role middleware_automation.keycloak.keycloak_role: realm: "{{ target_realm }}" client_id: "{{ client }}" name: "{{ client_role }}" state: absent - - name: keycloak_client — remove confidential client + - name: keycloak_client - remove confidential client middleware_automation.keycloak.keycloak_client: realm: "{{ target_realm }}" client_id: "{{ client }}" state: absent - - name: keycloak_client_scope — remove client scope + - name: keycloak_client_scope - remove client scope middleware_automation.keycloak.keycloak_client_scope: realm: "{{ target_realm }}" name: "{{ scope }}" state: absent - - name: keycloak_role — remove realm role + - name: keycloak_role - remove realm role middleware_automation.keycloak.keycloak_role: realm: "{{ target_realm }}" name: "{{ role }}" diff --git a/plugins/modules/keycloak_realm_key.py b/plugins/modules/keycloak_realm_key.py index c06a24f..9f61238 100644 --- a/plugins/modules/keycloak_realm_key.py +++ b/plugins/modules/keycloak_realm_key.py @@ -620,7 +620,7 @@ def get_keycloak_config_key(param_name, provider_id=None): """ # Handle elliptic_curve specially - each provider uses a different config key if param_name == "elliptic_curve" and provider_id in ELLIPTIC_CURVE_CONFIG_KEYS: - return ELLIPTIC_CURVE_CONFIG_KEYS[param_name] + return ELLIPTIC_CURVE_CONFIG_KEYS[provider_id] if param_name in CONFIG_PARAM_MAPPING: return CONFIG_PARAM_MAPPING[param_name] return camel(param_name)