an active user was deactivated

Author: ademk7604

src/test/java/org/ays/auth/controller/AysUserControllerTest.java

@@ -798,4 +798,29 @@ void givenUserDelete_whenUserUnauthorized_thenReturnAccessDeniedException() thro
                 .delete(Mockito.anyString());
     }
 
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "A",
+            "493268349068342"
+    })
+    void givenInvalidUserId_whenIdNotValid_thenReturnValidationErrorForPassivate(String invalidId) throws Exception {
+
+        // Then
+        String endpoint = BASE_PATH.concat("/user/").concat(invalidId).concat("/passivate");
+        MockHttpServletRequestBuilder mockHttpServletRequestBuilder = AysMockMvcRequestBuilders
+                .patch(endpoint, mockAdminToken.getAccessToken());
+
+        AysErrorResponse mockErrorResponse = AysErrorBuilder.VALIDATION_ERROR;
+
+        aysMockMvc.perform(mockHttpServletRequestBuilder, mockErrorResponse)
+                .andExpect(AysMockResultMatchersBuilders.status()
+                        .isBadRequest())
+                .andExpect(AysMockResultMatchersBuilders.subErrors()
+                        .isNotEmpty());
+
+        // Verify
+        Mockito.verify(userUpdateService, Mockito.never())
+                .passivate(Mockito.anyString());
+    }
+
 }

src/test/java/org/ays/auth/controller/AysUserEndToEndTest.java

@@ -373,6 +373,7 @@ void givenValidIdAndUserUpdateRequest_whenUserUpdated_thenReturnSuccess() throws
         Assertions.assertNotNull(userFromDatabase.get().getUpdatedAt());
     }
 
+
     @Test
     void givenValidId_whenActivateUser_thenReturnSuccess() throws Exception {
 
@@ -469,4 +470,49 @@ void givenValidId_whenUserDeleted_thenReturnSuccess() throws Exception {
         Assertions.assertEquals(AysUserStatus.DELETED, userFromDatabase.get().getStatus());
     }
 
+
+    @Test
+    void givenValidId_whenPassivateUser_thenReturnSuccess() throws Exception {
+
+        // Initialize
+        Institution institution = new InstitutionBuilder()
+                .withId(AysValidTestData.Admin.INSTITUTION_ID)
+                .build();
+
+        List<AysRole> roles = roleReadPort.findAllActivesByInstitutionId(institution.getId());
+
+        AysUser user = userSavePort.save(
+                new AysUserBuilder()
+                        .withId(AysRandomUtil.generateUUID())
+                        .withValidValues()
+                        .withRoles(roles)
+                        .withInstitution(institution)
+                        .withStatus(AysUserStatus.ACTIVE)  // Kullanıcı başlangıçta aktif
+                        .build()
+        );
+
+        // Given
+        String id = user.getId();
+
+        // Then
+        String endpoint = BASE_PATH.concat("/user/").concat(id).concat("/passivate");
+        MockHttpServletRequestBuilder mockHttpServletRequestBuilder = AysMockMvcRequestBuilders
+                .patch(endpoint, adminToken.getAccessToken());
+
+        AysResponse<Void> mockResponse = AysResponseBuilder.SUCCESS;
+
+        aysMockMvc.perform(mockHttpServletRequestBuilder, mockResponse)
+                .andExpect(AysMockResultMatchersBuilders.status()
+                        .isOk())
+                .andExpect(AysMockResultMatchersBuilders.response()
+                        .doesNotExist());
+
+        // Verify
+        Optional<AysUser> userFromDatabase = userReadPort.findById(user.getId());
+
+        Assertions.assertTrue(userFromDatabase.isPresent());
+        Assertions.assertEquals(userFromDatabase.get().getId(), user.getId());
+        Assertions.assertEquals(AysUserStatus.PASSIVE, userFromDatabase.get().getStatus());
+    }
+
 }

src/test/java/org/ays/auth/service/impl/AysAuthServiceImplTest.java

@@ -26,6 +26,7 @@
 import org.ays.auth.util.exception.AysTokenNotValidException;
 import org.ays.auth.util.exception.AysUserDoesNotAccessPageException;
 import org.ays.auth.util.exception.AysUserIdNotValidException;
+import org.ays.auth.util.exception.AysUserNotActiveException;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;

src/test/java/org/ays/auth/service/impl/AysUserUpdateServiceImplTest.java

@@ -17,6 +17,7 @@
 import org.ays.auth.util.exception.AysUserAlreadyExistsByEmailAddressException;
 import org.ays.auth.util.exception.AysUserAlreadyExistsByPhoneNumberException;
 import org.ays.auth.util.exception.AysUserIsNotActiveOrPassiveException;
+import org.ays.auth.util.exception.AysUserNotActiveException;
 import org.ays.auth.util.exception.AysUserNotExistByIdException;
 import org.ays.auth.util.exception.AysUserNotPassiveException;
 import org.ays.common.model.AysPhoneNumber;
@@ -820,4 +821,157 @@ void givenValidId_whenUserNotMatchedWithInstitution_thenThrowAysUserNotExistById
                 .save(Mockito.any(AysUser.class));
     }
 
+
+    @Test
+    void givenValidId_whenUserIsActive_thenPassivateUser() {
+
+        // Given
+        String mockId = "21a0ab5a-c0e9-4789-9704-a6b5c02e2325";
+
+        // When
+        Institution mockInstitution = new InstitutionBuilder()
+                .withValidValues()
+                .build();
+        Mockito.when(identity.getInstitutionId())
+                .thenReturn(mockInstitution.getId());
+
+        AysUser mockUser = new AysUserBuilder()
+                .withValidValues()
+                .withId(mockId)
+                .withInstitution(mockInstitution)
+                .withStatus(AysUserStatus.ACTIVE)
+                .build();
+
+        Mockito.when(userReadPort.findById(Mockito.anyString()))
+                .thenReturn(Optional.of(mockUser));
+
+        Mockito.when(userSavePort.save(Mockito.any(AysUser.class)))
+                .thenReturn(Mockito.mock(AysUser.class));
+
+        // Then
+        userUpdateService.passivate(mockId);
+
+        // Verify
+        Mockito.verify(identity, Mockito.times(1))
+                .getInstitutionId();
+
+        Mockito.verify(userReadPort, Mockito.times(1))
+                .findById(Mockito.anyString());
+
+        Mockito.verify(userSavePort, Mockito.times(1))
+                .save(Mockito.any(AysUser.class));
+    }
+
+    @Test
+    void givenValidUserId_whenUserNotFound_thenThrowAysUserNotExistByIdException(){
+
+        // Given
+        String mockId = "9f1eb072-7830-4c43-9a32-d77b62ccddd3";
+
+        // When
+        Mockito.when(userReadPort.findById(Mockito.anyString()))
+                .thenReturn(Optional.empty());
+
+        // Then
+        Assertions.assertThrows(
+                AysUserNotExistByIdException.class,
+                () -> userUpdateService.passivate(mockId)
+        );
+
+        // Verify
+        Mockito.verify(userReadPort, Mockito.times(1))
+                .findById(Mockito.anyString());
+
+        Mockito.verify(identity, Mockito.never())
+                .getInstitutionId();
+
+        Mockito.verify(userSavePort, Mockito.never())
+                .save(Mockito.any(AysUser.class));
+    }
+
+    @Test
+    void givenValidId_whenUserIsNotActive_thenThrowAysUserNotActiveException(){
+
+        // Given
+        String mockId = "bf7cc8d4-eab7-487d-8564-19be0f439b4a";
+
+        // When
+        Institution mockInstitution = new InstitutionBuilder()
+                .withValidValues()
+                .build();
+        Mockito.when(identity.getInstitutionId())
+                .thenReturn(mockInstitution.getId());
+
+        AysUser mockUser = new AysUserBuilder()
+                .withValidValues()
+                .withId(mockId)
+                .withInstitution(mockInstitution)
+                .withStatus(AysUserStatus.PASSIVE) // Not active
+                .build();
+
+        Mockito.when(userReadPort.findById(Mockito.anyString()))
+                .thenReturn(Optional.of(mockUser));
+
+        // Then
+        Assertions.assertThrows(
+                AysUserNotActiveException.class,
+                () -> userUpdateService.passivate(mockId)
+        );
+
+        // Verify
+        Mockito.verify(identity, Mockito.times(1))
+                .getInstitutionId();
+
+        Mockito.verify(userReadPort, Mockito.times(1))
+                .findById(Mockito.anyString());
+
+        Mockito.verify(userSavePort, Mockito.never())
+                .save(Mockito.any(AysUser.class));
+    }
+
+    @Test
+    void givenValidUserId_whenInstitutionIdDoesNotMatch_thenThrowAysUserNotExistByIdException() {
+
+        // Given
+        String mockId = "a785c6a2-229f-4a73-8e3a-3ff49bd16a07";
+
+        // When
+        Institution mockInstitution = new InstitutionBuilder()
+                .withValidValues()
+                .build();
+
+        Institution differentInstitution = new InstitutionBuilder()
+                .withValidValues()
+                .build();
+
+        AysUser mockUser = new AysUserBuilder()
+                .withValidValues()
+                .withId(mockId)
+                .withInstitution(differentInstitution)
+                .withStatus(AysUserStatus.ACTIVE)
+                .build();
+
+        Mockito.when(identity.getInstitutionId())
+                .thenReturn(mockInstitution.getId());
+
+        Mockito.when(userReadPort.findById(mockId))
+                .thenReturn(Optional.of(mockUser));
+
+        // Then
+        Assertions.assertThrows(
+                AysUserNotExistByIdException.class,
+                () -> userUpdateService.passivate(mockId)
+        );
+
+        // Verify
+        Mockito.verify(identity, Mockito.times(1))
+                .getInstitutionId();
+
+        Mockito.verify(userReadPort, Mockito.times(1))
+                .findById(mockId);
+
+        Mockito.verify(userSavePort, Mockito.never())
+                .save(mockUser);
+    }
+
 }