roomescape-refactored/src/test/java/roomescape/util/RoomescapeApiTest.kt

package roomescape.util

import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.ninjasquad.springmockk.MockkBean
import com.ninjasquad.springmockk.SpykBean
import io.kotest.core.spec.style.BehaviorSpec
import io.mockk.every
import org.springframework.data.repository.findByIdOrNull
import org.springframework.http.HttpHeaders
import org.springframework.http.HttpStatus
import org.springframework.http.MediaType
import org.springframework.test.web.servlet.*
import roomescape.auth.infrastructure.jwt.JwtHandler
import roomescape.auth.web.support.AdminInterceptor
import roomescape.auth.web.support.LoginInterceptor
import roomescape.auth.web.support.MemberIdResolver
import roomescape.common.exception.ErrorType
import roomescape.common.exception.RoomescapeException
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.Member
import roomescape.member.infrastructure.persistence.MemberRepository
import roomescape.util.MemberFixture.NOT_LOGGED_IN_USERID

abstract class RoomescapeApiTest : BehaviorSpec() {

    @SpykBean
    private lateinit var AdminInterceptor: AdminInterceptor

    @SpykBean
    private lateinit var loginInterceptor: LoginInterceptor

    @SpykBean
    private lateinit var memberIdResolver: MemberIdResolver

    @SpykBean
    lateinit var memberService: MemberService

    @MockkBean
    lateinit var memberRepository: MemberRepository

    @MockkBean
    lateinit var jwtHandler: JwtHandler

    val objectMapper: ObjectMapper = jacksonObjectMapper()
    val admin: Member = MemberFixture.admin()
    val user: Member = MemberFixture.user()

    fun runGetTest(
            mockMvc: MockMvc,
            endpoint: String,
            log: Boolean = false,
            assert: MockMvcResultMatchersDsl.() -> Unit
    ): ResultActionsDsl = mockMvc.get(endpoint) {
        header(HttpHeaders.COOKIE, "accessToken=token")
    }.apply {
        log.takeIf { it }?.let { this.andDo { print() } }
    }.andExpect(assert)

    fun runPostTest(
            mockMvc: MockMvc,
            endpoint: String,
            body: Any? = null,
            log: Boolean = false,
            assert: MockMvcResultMatchersDsl.() -> Unit
    ): ResultActionsDsl = mockMvc.post(endpoint) {
        this.header(HttpHeaders.COOKIE, "accessToken=token")
        body?.let {
            this.contentType = MediaType.APPLICATION_JSON
            this.content = objectMapper.writeValueAsString(it)
        }
    }.apply {
        log.takeIf { it }?.let { this.andDo { print() } }
    }.andExpect {
        assert
    }

    fun runDeleteTest(
            mockMvc: MockMvc,
            endpoint: String,
            log: Boolean = false,
            assert: MockMvcResultMatchersDsl.() -> Unit
    ): ResultActionsDsl = mockMvc.delete(endpoint) {
        header(HttpHeaders.COOKIE, "accessToken=token")
    }.apply {
        log.takeIf { it }?.let { this.andDo { print() } }
    }.andExpect {
        assert
    }

    fun loginAsAdmin() {
        every {
            jwtHandler.getMemberIdFromToken(any())
        } returns admin.id!!

        every { memberRepository.existsById(admin.id!!) } returns true
        every { memberRepository.findByIdOrNull(admin.id!!) } returns admin
    }

    fun loginAsUser() {
        every {
            jwtHandler.getMemberIdFromToken(any())
        } returns user.id!!

        every { memberRepository.existsById(user.id!!) } returns true
        every { memberRepository.findByIdOrNull(user.id!!) } returns user
    }

    fun doNotLogin() {
        every {
            jwtHandler.getMemberIdFromToken(any())
        } throws RoomescapeException(ErrorType.INVALID_TOKEN, HttpStatus.UNAUTHORIZED)

        every { memberRepository.existsById(NOT_LOGGED_IN_USERID) } returns false
        every { memberRepository.findByIdOrNull(NOT_LOGGED_IN_USERID) } returns null
    }

    fun <T> MvcResult.readValue(valueType: Class<T>): T = this.response.contentAsString
            .takeIf { it.isNotBlank() }
            ?.let { readValue(it, valueType) }
            ?: throw RuntimeException("""
                [Test] Exception occurred while reading response json: ${this.response.contentAsString} with value type: $valueType
            """.trimIndent())

    fun <T> readValue(responseJson: String, valueType: Class<T>): T = objectMapper
            .readTree(responseJson)["data"]
            ?.let { objectMapper.convertValue(it, valueType) }
            ?: throw RuntimeException("""
                [Test] Exception occurred while reading response json: $responseJson with value type: $valueType
            """.trimIndent())
}