Testing Authenticated API Endpoints with Kotlin

import okhttp3.OkHttpClient
import okhttp3.Request
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test

const val BASE_URL = "http://localhost:8000"
const val API_KEY = "123e4567-e89b-12d3-a456-426614174000"

class TestAPIKeyAuthentication {

    private val client = OkHttpClient()

    @Test
    fun TestAPIKey() {
        // Arrange
        val request = Request.Builder()
            .url("$BASE_URL/todos")
            .addHeader("X-API-Key", API_KEY)
            .build()

        // Act
        client.newCall(request).execute().use { response ->
            // Assert
            assertEquals(200, response.code)
        }
    }
}

import okhttp3.FormBody
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import org.junit.jupiter.api.BeforeEach

const val BASE_URL = "http://localhost:8000"

class TestSessionAuthentication {

    private val client = OkHttpClient()
    private val authDetails = mapOf(
        "username" to "testuser",
        "password" to "testpass123"
    )

    fun login(): Response {
        val formBody = FormBody.Builder()
            .add("username", authDetails["username"]!!)
            .add("password", authDetails["password"]!!)
            .build()

        val request = Request.Builder()
            .url("$BASE_URL/auth/login")
            .post(formBody)
            .build()

        return client.newCall(request).execute()
    }
}

@Test
fun test_login() {
    // Act - Execute the login process using the helper method
    val loginResponse = login()

    // Assert - Verify that the login was successful
    assertEquals(200, loginResponse.code)
}

@Test
fun test_access_with_session() {
    // Arrange - Use the login helper method to authenticate
    val loginResponse = login()
    val sessionCookie = loginResponse.header("Set-Cookie") ?: ""

    // Act - Request the protected resource using the session
    val request = Request.Builder()
        .url("$BASE_URL/todos")
        .addHeader("Cookie", sessionCookie)
        .build()

    client.newCall(request).execute().use { response ->
        // Assert - Confirm access is granted with a successful status code
        assertEquals(200, response.code)
    }
}

@Test
fun test_logout_with_session() {
    // Arrange - Use the login helper method to authenticate
    val loginResponse = login()
    val sessionCookie = loginResponse.header("Set-Cookie") ?: ""

    // Act - Perform a logout operation to terminate the session
    val request = Request.Builder()
        .url("$BASE_URL/auth/logout")
        .addHeader("Cookie", sessionCookie)
        .post(FormBody.Builder().build()) // Empty POST body for logout
        .build()

    client.newCall(request).execute().use { logoutResponse ->
        // Assert - Verify logout success via status code
        assertEquals(200, logoutResponse.code)
    }
}

import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.FormBody
import okhttp3.Response

const val BASE_URL = "http://localhost:8000"

class TestJWTAuthentication {

    private val client = OkHttpClient()
    private val authDetails = mapOf(
        "username" to "testuser",
        "password" to "testpass123"
    )

    fun login(): Response {
        val formBody = FormBody.Builder()
            .add("username", authDetails["username"]!!)
            .add("password", authDetails["password"]!!)
            .build()

        val request = Request.Builder()
            .url("$BASE_URL/auth/login")
            .post(formBody)
            .build()

        return client.newCall(request).execute()
    }
}

@Test
fun test_login() {
    // Act - Authenticate and retrieve JWT tokens
    val loginResponse = login()

    // Assert - Confirm receipt of tokens and check their existence
    assertEquals(200, loginResponse.code)

    val responseBody = loginResponse.body?.string() ?: ""
    val jsonResponse = Json.parseToJsonElement(responseBody).jsonObject

    assertTrue(jsonResponse.containsKey("access_token"))
    assertTrue(jsonResponse.containsKey("refresh_token"))
}

@Test
fun test_access_with_jwt() {
    // Arrange - Authenticate and obtain an access token using the helper method
    val loginResponse = login()
    val responseBody = loginResponse.body?.string() ?: ""
    val jsonResponse = Json.parseToJsonElement(responseBody).jsonObject
    val accessToken = jsonResponse["access_token"]?.jsonPrimitive?.content ?: ""

    // Act - Use the access token to request a protected endpoint
    val request = Request.Builder()
        .url("$BASE_URL/todos")
        .addHeader("Authorization", "Bearer $accessToken")
        .build()

    client.newCall(request).execute().use { response ->
        // Assert - Confirm the request was successful by checking the status code
        assertEquals(200, response.code)
    }
}

@Test
fun test_jwt_logout() {
    // Arrange - Authenticate and prepare tokens using the helper method
    val loginResponse = login()
    val responseBody = loginResponse.body?.string() ?: ""
    val jsonResponse = Json.parseToJsonElement(responseBody).jsonObject
    val accessToken = jsonResponse["access_token"]?.jsonPrimitive?.content ?: ""
    val refreshToken = jsonResponse["refresh_token"]?.jsonPrimitive?.content ?: ""

    // Act - Use access and refresh tokens to process logout
    val formBody = FormBody.Builder()
        .add("refresh_token", refreshToken)
        .build()

    val request = Request.Builder()
        .url("$BASE_URL/auth/logout")
        .addHeader("Authorization", "Bearer $accessToken")
        .post(formBody)
        .build()

    client.newCall(request).execute().use { logoutResponse ->
        // Assert - Verify logout success through confirmation of status code
        assertEquals(200, logoutResponse.code)
    }
}