diff --git a/frontend/app/src/main/java/com/example/speechbuddy/viewmodel/LoginViewModel.kt b/frontend/app/src/main/java/com/example/speechbuddy/viewmodel/LoginViewModel.kt
index ebbaf481..b6aec871 100644
--- a/frontend/app/src/main/java/com/example/speechbuddy/viewmodel/LoginViewModel.kt
+++ b/frontend/app/src/main/java/com/example/speechbuddy/viewmodel/LoginViewModel.kt
@@ -1,6 +1,5 @@
 package com.example.speechbuddy.viewmodel
 
-import android.util.Log
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
@@ -126,7 +125,6 @@ class LoginViewModel @Inject internal constructor(
                             }
                         } else if (it.message?.contains("email", ignoreCase = true) == true
                         ) { // email is wrong
-                            Log.d("email", "email")
                             _uiState.update { currentState ->
                                 currentState.copy(
                                     isValidEmail = false,
diff --git a/frontend/app/src/test/java/com/example/speechbuddy/LoginViewModelTest.kt b/frontend/app/src/test/java/com/example/speechbuddy/LoginViewModelTest.kt
index fa8ca9db..b7d17085 100644
--- a/frontend/app/src/test/java/com/example/speechbuddy/LoginViewModelTest.kt
+++ b/frontend/app/src/test/java/com/example/speechbuddy/LoginViewModelTest.kt
@@ -1,8 +1,10 @@
 package com.example.speechbuddy
 
+import android.util.Log
 import androidx.arch.core.executor.testing.InstantTaskExecutorRule
 import com.example.speechbuddy.data.remote.requests.AuthLoginRequest
 import com.example.speechbuddy.data.remote.requests.AuthSignupRequest
+import com.example.speechbuddy.domain.models.AuthToken
 import com.example.speechbuddy.repository.AuthRepository
 import com.example.speechbuddy.ui.models.LoginErrorType
 import com.example.speechbuddy.ui.models.SignupErrorType
@@ -37,10 +39,10 @@ class LoginViewModelTest {
     // boundary condition: 8 characters in password field
     private val validPassword = "password"
     private val shortPassword = "pwd"
-    private val wrongPassword = "wrong_password"
+    private val wrongPassword = "wrong_password" // valid format
     private val validEmail = "valid@test.com"
     private val invalidEmail = "invalid"
-    private val notRegisteredEmail = "not_registered@test.com"
+    private val unregisteredEmail = "unregistered@test.com" // valid format
     private val emptyString = ""
 
     @get:Rule
@@ -60,7 +62,7 @@ class LoginViewModelTest {
     }
 
     @Test
-    fun loginViewModel_setEmail_invalid_beforeSignupClick() {
+    fun `should set invalid email before login click when setemail is called with invalid email`() {
         viewModel.setEmail(invalidEmail)
 
         assertEquals(invalidEmail, viewModel.emailInput)
@@ -69,7 +71,7 @@ class LoginViewModelTest {
     }
 
     @Test
-    fun loginViewModel_setEmail_valid_beforeSignupClick() {
+    fun `should set valid email before login click when setemail is called with valid email`() {
         viewModel.setEmail(validEmail)
 
         assertEquals(validEmail, viewModel.emailInput)
@@ -78,7 +80,7 @@ class LoginViewModelTest {
     }
 
     @Test
-    fun loginViewModel_setEmail_invalid_afterSignupClick() {
+    fun `should set errortype email after login click when setemail is called with invalid email`() {
         viewModel.setEmail(invalidEmail)
 
         viewModel.login()
@@ -86,6 +88,13 @@ class LoginViewModelTest {
         assertEquals(invalidEmail, viewModel.emailInput)
         assertEquals(LoginErrorType.EMAIL, viewModel.uiState.value.error?.type)
         assertEquals(false, viewModel.uiState.value.isValidEmail)
+    }
+
+    @Test
+    fun `should set errortype null after login click when invalid email is changed to valid email`() {
+        viewModel.setEmail(invalidEmail)
+
+        viewModel.login()
 
         viewModel.setEmail(validEmail)
 
@@ -95,23 +104,42 @@ class LoginViewModelTest {
     }
 
     @Test
-    fun loginViewModel_setEmail_notRegistered_afterSignupClick() {
-        viewModel.setEmail(notRegisteredEmail)
+    fun `should set errortype email after login click when setemail is called with unregistered email`() {
+        viewModel.setEmail(unregisteredEmail)
         viewModel.setPassword(validPassword)
 
         coEvery {
-            repository.login(AuthLoginRequest(notRegisteredEmail, validPassword))
+            repository.login(AuthLoginRequest(unregisteredEmail, validPassword))
         } returns flowOf(
             Resource.error(
             "{\"code\":400,\"message\":{\"wrong_email\":[\"wrong email address\"]}}",
             null)
         )
+
         viewModel.login()
+        Thread.sleep(10) //viewModel.login() does not immediately produce result
 
-        assertEquals(notRegisteredEmail, viewModel.emailInput)
+        assertEquals(unregisteredEmail, viewModel.emailInput)
         assertEquals(LoginErrorType.EMAIL, viewModel.uiState.value.error?.type)
         assertEquals(R.string.false_email, viewModel.uiState.value.error?.messageId)
         assertEquals(false, viewModel.uiState.value.isValidEmail)
+    }
+
+    @Test
+    fun `should set errortype null after login click when unregistered email is changed to valid email`() {
+        viewModel.setEmail(unregisteredEmail)
+        viewModel.setPassword(validPassword)
+
+        coEvery {
+            repository.login(AuthLoginRequest(unregisteredEmail, validPassword))
+        } returns flowOf(
+            Resource.error(
+                "{\"code\":400,\"message\":{\"wrong_email\":[\"wrong email address\"]}}",
+                null)
+        )
+
+        viewModel.login()
+        Thread.sleep(10) //viewModel.login() does not immediately produce result
 
         viewModel.setEmail(validEmail)
 
@@ -120,210 +148,256 @@ class LoginViewModelTest {
         assertEquals(null, viewModel.uiState.value.error?.messageId)
         assertEquals(true, viewModel.uiState.value.isValidEmail)
     }
-/*
+
     @Test
-    fun loginViewModel_setEmail_valid_afterSignupClick() {
-        viewModel.setEmail(invalidEmail)
+    fun `should set errortype not email after login click when setemail is called with valid email`() {
+        viewModel.setEmail(validEmail)
+        viewModel.setPassword(wrongPassword)
+
+        coEvery {
+            repository.login(AuthLoginRequest(validEmail, wrongPassword))
+        } returns flowOf(
+            Resource.error(
+                "{\"code\":400,\"message\":{\"wrong_password\":[\"wrong password\"]}}",
+                null)
+        )
 
         viewModel.login()
+        Thread.sleep(10) //viewModel.login() does not immediately produce result
 
-        assertEquals(invalidEmail, viewModel.emailInput)
-        assertEquals(viewModel.uiState.value.error?.type, LoginErrorType.EMAIL)
-        assertEquals(viewModel.uiState.value.isValidEmail, false)
+        assertEquals(validEmail, viewModel.emailInput)
+        assertEquals(LoginErrorType.PASSWORD, viewModel.uiState.value.error?.type)
+        assertEquals(R.string.false_password, viewModel.uiState.value.error?.messageId)
+        assertEquals(false, viewModel.uiState.value.isValidEmail)
+    }
 
+    @Test
+    fun `should set errortype not email after login click when valid email is changed to invalid email`() {
         viewModel.setEmail(validEmail)
+        viewModel.setPassword(wrongPassword)
 
-        assertEquals(validEmail, viewModel.emailInput)
-        assertEquals(viewModel.uiState.value.error?.type, null)
-        assertEquals(viewModel.uiState.value.isValidEmail, true)
+        coEvery {
+            repository.login(AuthLoginRequest(validEmail, wrongPassword))
+        } returns flowOf(
+            Resource.error(
+                "{\"code\":400,\"message\":{\"wrong_password\":[\"wrong password\"]}}",
+                null)
+        )
+
+        viewModel.login()
+        Thread.sleep(10) //viewModel.login() does not immediately produce result
+
+        viewModel.setEmail(invalidEmail)
+
+        assertEquals(invalidEmail, viewModel.emailInput)
+        assertEquals(LoginErrorType.PASSWORD, viewModel.uiState.value.error?.type)
+        assertEquals(R.string.false_password, viewModel.uiState.value.error?.messageId)
+        assertEquals(false, viewModel.uiState.value.isValidEmail)
     }
 
     @Test
-    fun loginViewModel_setPassword_short_beforeSignupClick() {
+    fun `should set short password before login click when setpassword is called with short email`() {
         viewModel.setPassword(shortPassword)
 
         assertEquals(shortPassword, viewModel.passwordInput)
-        assertEquals(viewModel.uiState.value.error?.type, null)
-        assertEquals(viewModel.uiState.value.isValidPassword, false)
+        assertEquals(null, viewModel.uiState.value.error?.type)
+        assertEquals(false, viewModel.uiState.value.isValidPassword)
     }
 
     @Test
-    fun loginViewModel_setPassword_valid_beforeSignupClick() {
+    fun `should set valid password before login click when setpassword is called with valid email`(){
         viewModel.setPassword(validPassword)
 
         assertEquals(validPassword, viewModel.passwordInput)
-        assertEquals(viewModel.uiState.value.error?.type, null)
-        assertEquals(viewModel.uiState.value.isValidPassword, false)
+        assertEquals(null, viewModel.uiState.value.error?.type)
+        assertEquals(false, viewModel.uiState.value.isValidPassword)
     }
 
     @Test
-    fun loginViewModel_setPassword_short_afterSignupClick() {
+    fun `should set errortype password after login click when setpassword is called with short password`() {
+        viewModel.setEmail(validEmail)
         viewModel.setPassword(shortPassword)
-        viewModel.setNickname(validNickname)
 
-        viewModel.signup(validEmail)
+        viewModel.login()
 
         assertEquals(shortPassword, viewModel.passwordInput)
-        assertEquals(viewModel.uiState.value.error?.type, SignupErrorType.PASSWORD)
-        assertEquals(viewModel.uiState.value.isValidPassword, false)
+        assertEquals(LoginErrorType.PASSWORD, viewModel.uiState.value.error?.type)
+        assertEquals(false, viewModel.uiState.value.isValidPassword)
+    }
+
+    @Test
+    fun `should set errortype null after login click when short password is changed to valid password`() {
+        viewModel.setEmail(validEmail)
+        viewModel.setPassword(shortPassword)
+
+        viewModel.login()
 
         viewModel.setPassword(validPassword)
 
         assertEquals(validPassword, viewModel.passwordInput)
-        assertEquals(viewModel.uiState.value.error?.type, null)
-        assertEquals(viewModel.uiState.value.isValidPassword, true)
+        assertEquals(null, viewModel.uiState.value.error?.type)
+        assertEquals(true, viewModel.uiState.value.isValidPassword)
     }
 
     @Test
-    fun loginViewModel_setPassword_wrong_afterSignupClick() {
-        viewModel.setPassword(validPassword)
-
-        viewModel.signup(validEmail)
+    fun `should set errortype password after login click when setpassword is called with wrong password`(){
+        viewModel.setEmail(validEmail)
+        viewModel.setPassword(wrongPassword)
 
-        assertEquals(validPassword, viewModel.passwordInput)
-        assertEquals(viewModel.uiState.value.error?.type, SignupErrorType.NICKNAME)
-        assertEquals(viewModel.uiState.value.isValidPassword, false)
+        coEvery {
+            repository.login(AuthLoginRequest(validEmail, wrongPassword))
+        } returns flowOf(
+            Resource.error(
+                "{\"code\":400,\"message\":{\"wrong_password\":[\"wrong password\"]}}",
+                null)
+        )
 
-        viewModel.setPassword(shortPassword)
+        viewModel.login()
+        Thread.sleep(10) //viewModel.login() does not immediately produce result
 
-        assertEquals(shortPassword, viewModel.passwordInput)
-        assertEquals(viewModel.uiState.value.error?.type, SignupErrorType.NICKNAME)
-        assertEquals(viewModel.uiState.value.isValidPassword, false)
+        assertEquals(wrongPassword, viewModel.passwordInput)
+        assertEquals(LoginErrorType.PASSWORD, viewModel.uiState.value.error?.type)
+        assertEquals(false, viewModel.uiState.value.isValidPassword)
     }
 
-
     @Test
-    fun loginViewModel_setPassword_valid_afterSignupClick() {
-        viewModel.setPassword(validPassword)
-        viewModel.setPasswordCheck(shortPassword)
+    fun `should set errortype null after login click when wrong password is changed to valid password`(){
+        viewModel.setEmail(validEmail)
+        viewModel.setPassword(wrongPassword)
 
-        assertEquals(shortPassword, viewModel.passwordCheckInput)
-        assertEquals(viewModel.uiState.value.error?.type, null)
-        assertEquals(viewModel.uiState.value.isValidEmail, false)
-    }
+        coEvery {
+            repository.login(AuthLoginRequest(validEmail, wrongPassword))
+        } returns flowOf(
+            Resource.error(
+                "{\"code\":400,\"message\":{\"wrong_password\":[\"wrong password\"]}}",
+                null)
+        )
 
-    @Test
-    fun loginViewModel_login_invalidEmail_shortPassword() {
-        viewModel.setPassword(shortPassword)
-        viewModel.setPasswordCheck(validPassword)
+        viewModel.login()
+        Thread.sleep(10) //viewModel.login() does not immediately produce result
 
-        viewModel.signup(validEmail)
+        viewModel.setPassword(validPassword)
 
-        assertEquals(viewModel.uiState.value.isValidNickname, false)
-        assertEquals(viewModel.uiState.value.isValidPassword, false)
-        assertEquals(viewModel.uiState.value.isValidEmail, false)
-        assertEquals(viewModel.uiState.value.error?.type, SignupErrorType.NICKNAME)
-        assertEquals(viewModel.uiState.value.error?.messageId, R.string.nickname_length_error)
+        assertEquals(validPassword, viewModel.passwordInput)
+        assertEquals(null, viewModel.uiState.value.error?.type)
+        assertEquals(true, viewModel.uiState.value.isValidPassword)
     }
 
     @Test
-    fun loginViewModel_login_invalidEmail_validPassword() {
-        viewModel.setNickname(emptyNickname)
+    fun `should set errortype email when login is called with invalid email, short password`(){
+        viewModel.setEmail(invalidEmail)
         viewModel.setPassword(shortPassword)
-        viewModel.setPasswordCheck(shortPassword)
 
-        viewModel.signup(validEmail)
+        viewModel.login()
 
-        assertEquals(viewModel.uiState.value.isValidNickname, false)
-        assertEquals(viewModel.uiState.value.isValidPassword, false)
-        assertEquals(viewModel.uiState.value.isValidEmail, false)
-        assertEquals(viewModel.uiState.value.error?.type, SignupErrorType.NICKNAME)
-        assertEquals(viewModel.uiState.value.error?.messageId, R.string.nickname_length_error)
+        assertEquals(false, viewModel.uiState.value.isValidEmail)
+        assertEquals(false, viewModel.uiState.value.isValidPassword)
+        assertEquals(LoginErrorType.EMAIL, viewModel.uiState.value.error?.type)
+        assertEquals(R.string.false_email, viewModel.uiState.value.error?.messageId)
     }
 
     @Test
-    fun loginViewModel_login_notRegisteredEmail_shortPassword() {
-        viewModel.setNickname(emptyNickname)
+    fun `should set errortype email when login is called with invalid email, valid password`(){
+        viewModel.setEmail(invalidEmail)
         viewModel.setPassword(validPassword)
-        viewModel.setPasswordCheck(shortPassword)
 
-        viewModel.signup(validEmail)
+        viewModel.login()
 
-        assertEquals(viewModel.uiState.value.isValidNickname, false)
-        assertEquals(viewModel.uiState.value.isValidPassword, false)
-        assertEquals(viewModel.uiState.value.isValidEmail, false)
-        assertEquals(viewModel.uiState.value.error?.type, SignupErrorType.NICKNAME)
-        assertEquals(viewModel.uiState.value.error?.messageId, R.string.nickname_length_error)
+        assertEquals(false, viewModel.uiState.value.isValidEmail)
+        assertEquals(false, viewModel.uiState.value.isValidPassword)
+        assertEquals(LoginErrorType.EMAIL, viewModel.uiState.value.error?.type)
+        assertEquals(R.string.false_email, viewModel.uiState.value.error?.messageId)
     }
 
     @Test
-    fun loginViewModel_login_notRegisteredEmail_validPassword() {
-        viewModel.setNickname(emptyNickname)
-        viewModel.setPassword(validPassword)
-        viewModel.setPasswordCheck(validPassword)
+    fun `should set errortype email when login is called with unregistered email, short password`(){
+        viewModel.setEmail(unregisteredEmail)
+        viewModel.setPassword(shortPassword)
 
-        viewModel.signup(validEmail)
+        viewModel.login()
 
-        assertEquals(viewModel.uiState.value.isValidNickname, false)
-        assertEquals(viewModel.uiState.value.isValidPassword, false)
-        assertEquals(viewModel.uiState.value.isValidEmail, false)
-        assertEquals(viewModel.uiState.value.error?.type, SignupErrorType.NICKNAME)
-        assertEquals(viewModel.uiState.value.error?.messageId, R.string.nickname_length_error)
+        assertEquals(false, viewModel.uiState.value.isValidEmail)
+        assertEquals(false, viewModel.uiState.value.isValidPassword)
+        assertEquals(LoginErrorType.PASSWORD, viewModel.uiState.value.error?.type)
+        assertEquals(R.string.false_password, viewModel.uiState.value.error?.messageId)
     }
 
     @Test
-    fun loginViewModel_login_validEmail_shortPassword() {
-        viewModel.setNickname(longNickname)
-        viewModel.setPassword(shortPassword)
-        viewModel.setPasswordCheck(validPassword)
+    fun `should set errortype email when login is called with unregistered email, valid password`(){
+        viewModel.setEmail(unregisteredEmail)
+        viewModel.setPassword(validPassword)
+
+        coEvery {
+            repository.login(AuthLoginRequest(unregisteredEmail, validPassword))
+        } returns flowOf(
+            Resource.error(
+                "{\"code\":400,\"message\":{\"wrong_email\":[\"wrong email address\"]}}",
+                null)
+        )
+
+        viewModel.login()
+        Thread.sleep(10) //viewModel.login() does not immediately produce result
 
-        viewModel.signup(validEmail)
+        assertEquals(false, viewModel.uiState.value.isValidEmail)
+        assertEquals(false, viewModel.uiState.value.isValidPassword)
+        assertEquals(LoginErrorType.EMAIL, viewModel.uiState.value.error?.type)
+        assertEquals(R.string.false_email, viewModel.uiState.value.error?.messageId)
 
-        assertEquals(viewModel.uiState.value.isValidNickname, false)
-        assertEquals(viewModel.uiState.value.isValidPassword, false)
-        assertEquals(viewModel.uiState.value.isValidEmail, false)
-        assertEquals(viewModel.uiState.value.error?.type, SignupErrorType.NICKNAME)
-        assertEquals(viewModel.uiState.value.error?.messageId, R.string.nickname_length_error)
     }
 
     @Test
-    fun loginViewModel_login_validEmail_wrongPassword() {
-        viewModel.setNickname(longNickname)
+    fun `should set errortype password when login is called with valid email, short password`(){
+        viewModel.setEmail(validEmail)
         viewModel.setPassword(shortPassword)
-        viewModel.setPasswordCheck(shortPassword)
 
-        viewModel.signup(validEmail)
+        viewModel.login()
+
+        assertEquals(false, viewModel.uiState.value.isValidEmail)
+        assertEquals(false, viewModel.uiState.value.isValidPassword)
+        assertEquals(LoginErrorType.PASSWORD, viewModel.uiState.value.error?.type)
+        assertEquals(R.string.false_password, viewModel.uiState.value.error?.messageId)
 
-        assertEquals(viewModel.uiState.value.isValidNickname, false)
-        assertEquals(viewModel.uiState.value.isValidPassword, false)
-        assertEquals(viewModel.uiState.value.isValidEmail, false)
-        assertEquals(viewModel.uiState.value.error?.type, SignupErrorType.NICKNAME)
-        assertEquals(viewModel.uiState.value.error?.messageId, R.string.nickname_length_error)
     }
 
     @Test
-    fun loginViewModel_login_validEmail_validPassword() {
-        val authSignupRequest = AuthSignupRequest(validEmail, validPassword, validNickname)
-        coEvery { repository.signup(authSignupRequest) } returns flowOf(Resource.success(null))
+    fun `should set errortype password when login is called with valid email, wrong password`(){
+        viewModel.setEmail(validEmail)
+        viewModel.setPassword(wrongPassword)
 
-        viewModel.setNickname(validNickname)
-        viewModel.setPassword(validPassword)
-        viewModel.setPasswordCheck(validPassword)
+        coEvery {
+            repository.login(AuthLoginRequest(validEmail, wrongPassword))
+        } returns flowOf(
+            Resource.error(
+                "{\"code\":400,\"message\":{\"wrong_password\":[\"wrong password\"]}}",
+                null)
+        )
 
-        viewModel.signup(validEmail)
+        viewModel.login()
+        Thread.sleep(10) //viewModel.login() does not immediately produce result
 
-        assertEquals(viewModel.signupResult.value?.message, null)
-        assertEquals(viewModel.signupResult.value?.data, null)
+        assertEquals(false, viewModel.uiState.value.isValidEmail)
+        assertEquals(false, viewModel.uiState.value.isValidPassword)
+        assertEquals(LoginErrorType.PASSWORD, viewModel.uiState.value.error?.type)
+        assertEquals(R.string.false_password, viewModel.uiState.value.error?.messageId)
     }
 
     @Test
-    fun loginViewModel_clearInputs() {
-        viewModel.setNickname(validNickname)
+    fun `should login success when login is called with valid email, valid password`(){
+        viewModel.setEmail(validEmail)
         viewModel.setPassword(validPassword)
-        viewModel.setPasswordCheck(validPassword)
 
-        assertEquals(validNickname, viewModel.nicknameInput)
-        assertEquals(validPassword, viewModel.passwordInput)
-        assertEquals(validPassword, viewModel.passwordCheckInput)
+        val authToken = AuthToken("access", "refresh")
+        coEvery {
+            repository.login(AuthLoginRequest(validEmail, validPassword))
+        } returns flowOf(
+            Resource.success(authToken)
+        )
 
-        viewModel.clearInputs()
+        viewModel.login()
+        Thread.sleep(10) //viewModel.login() does not immediately produce result
 
-        assertEquals(emptyString, viewModel.nicknameInput)
-        assertEquals(emptyString, viewModel.passwordInput)
-        assertEquals(emptyString, viewModel.passwordCheckInput)
+        assertEquals(null, viewModel.loginResult.value?.message)
+        assertEquals(authToken, viewModel.loginResult.value?.data)
     }
 
- */
-
-
 }
\ No newline at end of file