feat(admin): 콘텐츠 관리자 로그인 API 추가

src/test/kotlin/kr/co/vividnext/sodalive/admin/member/AdminMemberLoginControllerTest.kt

@@ -0,0 +1,66 @@
+package kr.co.vividnext.sodalive.admin.member
+
+import kr.co.vividnext.sodalive.member.MemberRole
+import kr.co.vividnext.sodalive.member.login.LoginRequest
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import org.mockito.Mockito
+import org.springframework.http.MediaType
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
+import org.springframework.test.web.servlet.setup.MockMvcBuilders
+
+class AdminMemberLoginControllerTest {
+    private lateinit var service: AdminMemberLoginService
+    private lateinit var controller: AdminMemberLoginController
+    private lateinit var mockMvc: MockMvc
+
+    @BeforeEach
+    fun setup() {
+        service = mock()
+        controller = AdminMemberLoginController(service = service)
+        mockMvc = MockMvcBuilders.standaloneSetup(controller).build()
+    }
+
+    @Test
+    @DisplayName("POST /admin/member/login은 token과 role을 응답한다")
+    fun shouldReturnTokenAndRole() {
+        val request = LoginRequest(email = "admin@test.com", password = "password")
+        val loginResponse = AdminMemberLoginResponse(token = "admin-token", role = MemberRole.ADMIN)
+        Mockito.`when`(service.login(request)).thenReturn(loginResponse)
+
+        val response = controller.login(request)
+
+        assertTrue(response.success)
+        assertEquals("admin-token", response.data?.token)
+        assertEquals(MemberRole.ADMIN, response.data?.role)
+    }
+
+    @Test
+    @DisplayName("POST /admin/member/login은 JSON으로 token과 role을 응답한다")
+    fun shouldReturnTokenAndRoleJson() {
+        val request = LoginRequest(email = "content@test.com", password = "password")
+        Mockito.`when`(service.login(request)).thenReturn(
+            AdminMemberLoginResponse(token = "content-token", role = MemberRole.CONTENT_MANAGER)
+        )
+
+        mockMvc.perform(
+            post("/admin/member/login")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("""{"email":"content@test.com","password":"password"}""")
+        )
+            .andExpect(status().isOk)
+            .andExpect(jsonPath("$.success").value(true))
+            .andExpect(jsonPath("$.data.token").value("content-token"))
+            .andExpect(jsonPath("$.data.role").value("CONTENT_MANAGER"))
+    }
+
+    private inline fun <reified T> mock(): T {
+        return Mockito.mock(T::class.java)
+    }
+}

src/test/kotlin/kr/co/vividnext/sodalive/admin/member/AdminMemberLoginServiceTest.kt

@@ -0,0 +1,98 @@
+package kr.co.vividnext.sodalive.admin.member
+
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.jwt.TokenProvider
+import kr.co.vividnext.sodalive.member.Member
+import kr.co.vividnext.sodalive.member.MemberRepository
+import kr.co.vividnext.sodalive.member.MemberRole
+import kr.co.vividnext.sodalive.member.login.LoginRequest
+import kr.co.vividnext.sodalive.member.token.MemberTokenRepository
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertThrows
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import org.mockito.Mockito
+import org.springframework.security.crypto.password.PasswordEncoder
+
+class AdminMemberLoginServiceTest {
+    private lateinit var repository: AdminMemberRepository
+    private lateinit var passwordEncoder: PasswordEncoder
+    private lateinit var tokenRepository: MemberTokenRepository
+    private lateinit var service: AdminMemberLoginService
+
+    @BeforeEach
+    fun setup() {
+        repository = mock()
+        passwordEncoder = mock()
+        tokenRepository = mock()
+        val tokenProvider = TokenProvider(
+            secret = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
+            tokenValidityInSeconds = 3600,
+            repository = mock<MemberRepository>(),
+            tokenRepository = tokenRepository
+        )
+        tokenProvider.afterPropertiesSet()
+        service = AdminMemberLoginService(
+            repository = repository,
+            passwordEncoder = passwordEncoder,
+            tokenProvider = tokenProvider
+        )
+    }
+
+    @Test
+    @DisplayName("관리자는 관리자 로그인 API로 token과 role을 받는다")
+    fun shouldLoginAdmin() {
+        val member = createMember(id = 1L, role = MemberRole.ADMIN)
+        Mockito.`when`(repository.findByEmail("admin@test.com")).thenReturn(member)
+        Mockito.`when`(passwordEncoder.matches("password", "encoded-password")).thenReturn(true)
+
+        val response = service.login(LoginRequest(email = "admin@test.com", password = "password"))
+
+        assertTrue(response.token.isNotBlank())
+        assertEquals(MemberRole.ADMIN, response.role)
+    }
+
+    @Test
+    @DisplayName("콘텐츠 관리자는 관리자 로그인 API로 token과 role을 받는다")
+    fun shouldLoginContentManager() {
+        val member = createMember(id = 2L, role = MemberRole.CONTENT_MANAGER)
+        Mockito.`when`(repository.findByEmail("content@test.com")).thenReturn(member)
+        Mockito.`when`(passwordEncoder.matches("password", "encoded-password")).thenReturn(true)
+
+        val response = service.login(LoginRequest(email = "content@test.com", password = "password"))
+
+        assertTrue(response.token.isNotBlank())
+        assertEquals(MemberRole.CONTENT_MANAGER, response.role)
+    }
+
+    @Test
+    @DisplayName("일반 사용자는 관리자 로그인 API를 사용할 수 없다")
+    fun shouldRejectUser() {
+        val member = createMember(id = 3L, role = MemberRole.USER)
+        Mockito.`when`(repository.findByEmail("user@test.com")).thenReturn(member)
+
+        val exception = assertThrows(SodaException::class.java) {
+            service.login(LoginRequest(email = "user@test.com", password = "password"))
+        }
+
+        assertEquals("common.error.bad_credentials", exception.messageKey)
+        Mockito.verifyNoInteractions(tokenRepository)
+    }
+
+    private fun createMember(id: Long, role: MemberRole): Member {
+        val member = Member(
+            email = "member$id@test.com",
+            password = "encoded-password",
+            nickname = "member$id",
+            role = role
+        )
+        member.id = id
+        return member
+    }
+
+    private inline fun <reified T> mock(): T {
+        return Mockito.mock(T::class.java)
+    }
+}