src/test/java/roomescape/util/Fixtures.kt

@@ -7,6 +7,8 @@ import roomescape.auth.web.LoginRequest
 import java.util.concurrent.atomic.AtomicLong
 
 object MemberFixture {
+    const val NOT_LOGGED_IN_USERID: Long = 0
+
     val idCounter: AtomicLong = AtomicLong(1L)
 
     fun create(

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

@@ -1,30 +1,40 @@
 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 io.restassured.http.ContentType
-import io.restassured.module.kotlin.extensions.Given
-import io.restassured.module.kotlin.extensions.Then
-import io.restassured.module.kotlin.extensions.When
-import io.restassured.response.ValidatableResponse
-import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.boot.test.web.server.LocalServerPort
 import org.springframework.data.repository.findByIdOrNull
+import org.springframework.http.HttpHeaders
 import org.springframework.http.HttpStatus
-import roomescape.member.infrastructure.persistence.Member
+import org.springframework.http.MediaType
-import roomescape.member.infrastructure.persistence.MemberRepository
+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
 
-const val NOT_LOGGED_IN_USERID: Long = 0;
+abstract class RoomescapeApiTest : BehaviorSpec() {
 
-@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+    @SpykBean
-@NoSqlInitialize
+    private lateinit var AdminInterceptor: AdminInterceptor
-class RoomescapeApiTest(
+
-        @LocalServerPort val port: Int? = 9090,
+    @SpykBean
-) : BehaviorSpec() {
+    private lateinit var loginInterceptor: LoginInterceptor
+
+    @SpykBean
+    private lateinit var memberIdResolver: MemberIdResolver
+
+    @SpykBean
+    lateinit var memberService: MemberService
 
     @MockkBean
     lateinit var memberRepository: MemberRepository
@@ -32,36 +42,42 @@ class RoomescapeApiTest(
     @MockkBean
     lateinit var jwtHandler: JwtHandler
 
-
+    val objectMapper: ObjectMapper = jacksonObjectMapper()
     val admin: Member = MemberFixture.admin()
     val user: Member = MemberFixture.user()
 
-    fun runGetTest(endpoint: String, token: String? = "token", assert: ValidatableResponse.() -> Unit): ValidatableResponse {
+    fun runGetTest(
-        return Given {
+            mockMvc: MockMvc,
-            port(port!!)
+            endpoint: String,
-            header("Cookie", "accessToken=$token")
+            log: Boolean = false,
-        } When {
+            assert: MockMvcResultMatchersDsl.() -> Unit
-            get(endpoint)
+    ): ResultActionsDsl = mockMvc.get(endpoint) {
-        } Then assert
+        header(HttpHeaders.COOKIE, "accessToken=token")
+    }.apply {
+        log.takeIf { it }?.let { this.andDo { print() } }
+    }.andExpect {
+        assert
     }
 
     fun runPostTest(
+            mockMvc: MockMvc,
             endpoint: String,
-            token: String? = "token",
             body: Any? = null,
-            assert: ValidatableResponse.() -> Unit
+            log: Boolean = false,
-    ): ValidatableResponse {
+            assert: MockMvcResultMatchersDsl.() -> Unit
-        return Given {
+    ): ResultActionsDsl = mockMvc.post(endpoint) {
-            port(port!!)
+        this.header(HttpHeaders.COOKIE, "accessToken=token")
-            contentType(ContentType.JSON)
+        body?.let {
-            body?.let { body(it) }
+            this.contentType = MediaType.APPLICATION_JSON
-            header("Cookie", "accessToken=$token")
+            this.content = objectMapper.writeValueAsString(it)
-        } When {
+        }
-            post(endpoint)
+    }.apply {
-        } Then assert
+        log.takeIf { it }?.let { this.andDo { print() } }
+    }.andExpect {
+        assert
     }
 
-    fun setUpAdmin() {
+    fun loginAsAdmin() {
         every {
             jwtHandler.getMemberIdFromToken(any())
         } returns admin.id!!
@@ -70,7 +86,7 @@ class RoomescapeApiTest(
         every { memberRepository.findByIdOrNull(admin.id!!) } returns admin
     }
 
-    fun setUpUser() {
+    fun loginAsUser() {
         every {
             jwtHandler.getMemberIdFromToken(any())
         } returns user.id!!
@@ -79,15 +95,19 @@ class RoomescapeApiTest(
         every { memberRepository.findByIdOrNull(user.id!!) } returns user
     }
 
-    fun setUpNotLoggedIn() {
+    fun doNotLogin() {
         every {
             jwtHandler.getMemberIdFromToken(any())
-        } returns NOT_LOGGED_IN_USERID
+        } throws RoomescapeException(ErrorType.INVALID_TOKEN, HttpStatus.UNAUTHORIZED)
 
-        every { memberRepository.existsById(NOT_LOGGED_IN_USERID) } throws RoomescapeException(
+        every { memberRepository.existsById(NOT_LOGGED_IN_USERID) } returns false
-                ErrorType.LOGIN_REQUIRED,
-                HttpStatus.FORBIDDEN
-        )
         every { memberRepository.findByIdOrNull(NOT_LOGGED_IN_USERID) } returns null
     }
+
+    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())
 }