---

package ru.domrf.elka.user_session;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;

/**
 * Интеграционный тест Spring Boot
 */
@SpringBootTest
@ActiveProfiles({"test"})
@TestPropertySource(properties = {"spring.config.location = classpath:application-test.yml"})
public interface SpringBootIT extends IntegrationTest {
}



package ru.domrf.elka.user_session;

/**
 * Интеграционный тест
 *
 * @author Сергей Николаев
 */
public interface IntegrationTest {

}

spring:
  cloud:
    vault:
      enabled: false
  application:
    name: "elka-${STAND:local}-user-session"
  security:
    oauth2:
      resource-server:
        jwt:
          issuer-uri: http://localhost:8080
          jwk-set-uri: http://localhost:8080
      client:
        registration:
          keycloak:
            provider: keycloak
            clientId: user-session
            clientSecret: secret
            authorizationGrantType: client_credentials
        provider:
          keycloak:
            token-uri: http://localhost:8080
  liquibase:
    drop-first: false
    enabled: false
  redis:
    mode: standalone
    host: localhost
    port: 6379
    cluster-nodes: localhost:6379


lib-rest-api:
  version: 1.0.0
  api:
    path: "/api"
    actuator: "/actuator"
    health: "/health"
    metrics: "/metrics"
    prometheus: "/prometheus"

keycloak:
  auth-server-url: http://localhost:8484/auth/realms/
  realm: elka_test
  client-id: elka.user-session
  client-secret: 91428589-6686-4e06
  scope: "openid profile email"
  response-type: "code"

integration:
  rest:
    role-model:
      path: http://localhost:8080
      user-roles: /v1/users/%s/roles
    sync-gateway:
      path: http://localhost:8080
      organizations: /v2/organizations
      organizations-timeout: 10000
      accounts: /v5/accounts
      accounts-timeout: 10000
      users: /v1/users/%s/%s
      users-timeout: 10000

user-session:
  v1:
    userInfo: http

security:
  http:
    check-bearer-token: false
    enable-s2s-auth: false
    user-info:
      check-signature: false

app:
  version: 1.0.0
  session-expiration-delta-per-sec: 10
  user-request-duration: 10
  api:
    v1:
      login: "/v1/login"
      callback-login: "/v1/callback-login"
      auth: "/v1/auth"
      check-session: "/v1/check-session"
      userinfo: "/v1/userinfo"
      logout: "/v1/logout"
      callback-logout: "/v1/callback-logout"
      callback-back-channel: "/v1/callback-backchannel"
    v2:
      auth: "/v2/auth"
    v3:
      auth: "/v3/auth"

async:
  corePoolSize: 5
  maxPoolSize: 10
  queueCapacity: 25

allowed-redirect-url-list:

event-logging:
  console:
    enabled: true

package ru.domrf.elka.user_session.test_data;

import lombok.NoArgsConstructor;
import lombok.NonNull;
import org.keycloak.representations.AccessTokenResponse;
import org.springframework.lang.Nullable;
import ru.domrf.elka.user_session.model.Session;
import ru.domrf.elka.user_session.model.SessionScopes;

import java.time.ZonedDateTime;

import static java.util.Objects.requireNonNull;
import static java.util.UUID.randomUUID;
import static lombok.AccessLevel.PRIVATE;
import static ru.domrf.elka.user_session.test_data.AccessTokenResponseTestData.expectedAccessTokenResponse;
import static ru.domrf.elka.user_session.test_data.CurrentSessionTestData.CURRENT_DOMLOGIN_SESSION_ID;
import static ru.domrf.elka.user_session.test_data.CurrentSessionTestData.CURRENT_SESSION_ID;
import static ru.domrf.elka.user_session.test_data.RoleSessionScopeTestData.twoRolesScopeTestData;
import static ru.domrf.elka.user_session.test_data.SessionScopesTestData.sessionScopesTestData;
import static ru.domrf.elka.user_session.test_data.SessionScopesTestData.sessionScopesWithAccountTestData;
import static ru.domrf.elka.user_session.test_data.SessionScopesTestData.sessionScopesWithOneRoleAndAllScopesTestData;
import static ru.domrf.elka.user_session.test_data.SessionScopesTestData.sessionScopesWithOrganizationTestData;
import static ru.domrf.elka.user_session.test_data.SessionScopesTestData.sessionScopesWithTwoRolesAndAllScopesTestData;

/**
 * Тестовые данные {@link Session}.
 */
@NoArgsConstructor(access = PRIVATE)
public class SessionTestData {

    public static final String ACCESS_EXPIRED = "2022-11-17T13:16:03Z[UTC]";
    public static final ZonedDateTime ACCESS_EXPIRED_DATE_TIME = ZonedDateTime.parse(ACCESS_EXPIRED);

    @NonNull
    public static Session sessionRandomId() {
        final var session = sessionNotNullId();
        session.setId(randomUUID().toString());
        return session;
    }

    @NonNull
    public static Session sessionNotNullId() {
        return instance(CURRENT_SESSION_ID, expectedAccessTokenResponse(),
                sessionScopesTestData(false));
    }

    @NonNull
    public static Session sessionIdNotNullHaveRole() {
        return instance(CURRENT_SESSION_ID, expectedAccessTokenResponse(), sessionScopesTestData(true));
    }

    @NonNull
    public static Session sessionWithTwoRole() {
        final var scope = sessionScopesTestData(true);
        scope.setRoles(twoRolesScopeTestData());

        return instance(CURRENT_SESSION_ID, expectedAccessTokenResponse(), scope);
    }

    @NonNull
    public static Session sessionIdNotNullEmptyRole() {
        return instance(CURRENT_SESSION_ID, expectedAccessTokenResponse(),
                sessionScopesTestData(false));
    }

    @NonNull
    public static Session sessionIsNullIdHaveRole() {
        return instance(null, expectedAccessTokenResponse(), sessionScopesTestData(true));
    }

    @NonNull
    public static Session sessionIsNullIdEmptyRole() {
        return instance(null, expectedAccessTokenResponse(),
                sessionScopesTestData(false));
    }

    @NonNull
    public static Session emptySessionWithId(@NonNull final String sessionId) {
        final Session instance = new Session();
        instance.setId(sessionId);
        instance.setDomLoginSessionId(CURRENT_DOMLOGIN_SESSION_ID);
        instance.setScopes(new SessionScopes());
        return instance;
    }

    @NonNull
    public static Session sessionWithAllScopesAndOneRole() {
        return instance(CURRENT_SESSION_ID, expectedAccessTokenResponse(),
                sessionScopesWithOneRoleAndAllScopesTestData());
    }

    @NonNull
    public static Session sessionWithAllScopesAndTwoRoles() {
        return instance(CURRENT_SESSION_ID, expectedAccessTokenResponse(),
                sessionScopesWithTwoRolesAndAllScopesTestData());
    }

    @NonNull
    public static Session sessionWithOrganizationScopes() {
        var scopes = sessionScopesWithOrganizationTestData();
        scopes.setRoles(twoRolesScopeTestData());
        return instance(CURRENT_SESSION_ID, expectedAccessTokenResponse(),
                scopes);
    }

    @NonNull
    public static Session sessionWithAccountScopes() {
        var scope = sessionScopesWithAccountTestData();
        scope.setRoles(twoRolesScopeTestData());
        return instance(CURRENT_SESSION_ID, expectedAccessTokenResponse(), scope);
    }

    @NonNull
    private static Session instance(@Nullable final String sessionId,
                                    @Nullable final AccessTokenResponse accessTokenResponse,
                                    @NonNull final SessionScopes scopes) {
        final Session instance = new Session();
        instance.setId(sessionId);
        instance.setDomLoginSessionId(CURRENT_DOMLOGIN_SESSION_ID);
        instance.setExpiresIn(200L);
        instance.setRefreshExpiresIn(requireNonNull(accessTokenResponse).getRefreshExpiresIn());
        instance.setAccessToken(accessTokenResponse.getToken());
        instance.setRefreshToken(accessTokenResponse.getRefreshToken());
        instance.setNotBeforePolicy(accessTokenResponse.getNotBeforePolicy());
        instance.setTokenType(accessTokenResponse.getTokenType());
        instance.setSessionState(accessTokenResponse.getSessionState());
        instance.setExpireDateTime(CurrentSessionTestData.CURRENT_SESSION_EXPIRED_DATETIME);
        instance.setAccessExpireDateTime(SessionTestData.ACCESS_EXPIRED_DATE_TIME);
        instance.setScopes(scopes);
        return instance;
    }

}