PasswordServiceTest 추가 - 최근 비밀번호 중복 검사 로직 수정

TestCleanupService 확장 - 초대/회원 소속 관리 메서드 구현
API 추가 - 초대 삭제 및 소속 제외, 사용자 존재 여부 확인

src/test/java/com/eactive/apim/portal/apps/user/PasswordServiceTest.java

@@ -0,0 +1,71 @@
+package com.eactive.apim.portal.apps.user;
+
+import com.eactive.apim.portal.apps.user.service.PasswordService;
+import com.eactive.apim.portal.common.dto.PasswordValidationDTO;
+import com.eactive.apim.portal.portaluser.entity.PortalUser;
+import com.eactive.apim.portal.portaluser.entity.UserPasswordHistory;
+import com.eactive.apim.portal.portaluser.repository.PortalUserRepository;
+import com.eactive.apim.portal.portaluser.repository.UserPasswordHistoryRepository;
+import java.util.Collections;
+import java.util.Optional;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class PasswordServiceTest {
+
+    @Mock
+    private PortalUserRepository portalUserRepository;
+    @Mock
+    private UserPasswordHistoryRepository passwordHistoryRepository;
+    @Mock
+    private PasswordEncoder passwordEncoder;
+    @Mock
+    private LocalValidatorFactoryBean validator;
+
+    @InjectMocks
+    private PasswordService passwordService;
+
+    @Test
+    void rejectsPasswordStoredAgainstPortalUserId() {
+        PortalUser user = new PortalUser();
+        user.setId("user-uuid");
+        user.setLoginId("user@example.com");
+        user.setMobileNumber("010-1234-5678");
+        user.setPasswordHash("temporary-password-hash");
+
+        UserPasswordHistory previousPassword = new UserPasswordHistory();
+        previousPassword.setUserId("user-uuid");
+        previousPassword.setPasswordHash("original-password-hash");
+
+        when(portalUserRepository.findByLoginId("user@example.com")).thenReturn(Optional.of(user));
+        when(passwordEncoder.matches("Original!123", "temporary-password-hash")).thenReturn(false);
+        when(validator.validate(any(PasswordValidationDTO.class))).thenReturn(Collections.emptySet());
+        when(passwordHistoryRepository.findRecentPasswordsByUserId("user-uuid"))
+            .thenReturn(Collections.singletonList(previousPassword));
+        when(passwordEncoder.matches("Original!123", "original-password-hash")).thenReturn(true);
+
+        IllegalArgumentException exception = assertThrows(
+            IllegalArgumentException.class,
+            () -> passwordService.updatePassword(
+                "user@example.com", "Original!123", "Original!123")
+        );
+
+        assertEquals("최근 5회 이내에 사용한 비밀번호는 사용할 수 없습니다.", exception.getMessage());
+        verify(passwordHistoryRepository).findRecentPasswordsByUserId("user-uuid");
+        verify(passwordHistoryRepository, never()).findRecentPasswordsByUserId("user@example.com");
+        verify(portalUserRepository, never()).save(user);
+    }
+}

src/test/java/com/eactive/apim/portal/djb/testcleanup/service/TestCleanupServiceTest.java

@@ -2,6 +2,7 @@ package com.eactive.apim.portal.djb.testcleanup.service;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.anyLong;
@@ -22,6 +23,7 @@ import com.eactive.apim.portal.djb.webhook.repository.WebhookRequestEventReposit
 import com.eactive.apim.portal.djb.webhook.repository.WebhookRequestRepository;
 import com.eactive.apim.portal.djb.webhook.repository.entity.WebhookRequest;
 import com.eactive.apim.portal.djb.webhook.service.WebhookService;
+import com.eactive.apim.portal.invitation.repository.UserInvitationRepository;
 import com.eactive.apim.portal.portalorg.entity.PortalOrg;
 import com.eactive.apim.portal.portaluser.entity.PortalUser;
 import com.eactive.apim.portal.portaluser.repository.PortalUserPrivacyAgreementRepository;
@@ -60,6 +62,7 @@ class TestCleanupServiceTest {
     @Mock private WebhookRequestApiRepository webhookRequestApiRepository;
     @Mock private WebhookRequestEventRepository webhookRequestEventRepository;
     @Mock private WebhookService webhookService;
+    @Mock private UserInvitationRepository userInvitationRepository;
     @Mock private TestCleanupNativeQueries nativeQueries;
 
     private TestCleanupService service;
@@ -76,7 +79,7 @@ class TestCleanupServiceTest {
                 inquiryRepository, inquiryCommentRepository, partnershipApplicationRepository,
                 userRoleHistoryRepository, portalUserPrivacyAgreementRepository, userPasswordHistoryRepository,
                 userLogRepository, credentialRepository, webhookRequestRepository, webhookRequestApiRepository,
-                webhookRequestEventRepository, webhookService, nativeQueries);
+                webhookRequestEventRepository, webhookService, userInvitationRepository, nativeQueries);
         when(environment.acceptsProfiles(Profiles.of("stage", "prod"))).thenReturn(false);
     }
 
@@ -98,6 +101,24 @@ class TestCleanupServiceTest {
         verifyNoInteractions(webhookService, portalUserRepository);
     }
 
+    @Test
+    void deleteOrgCascade_fallsBackToDigitsOnlyBusinessNumber() {
+        String hyphenatedCompRegNo = "123-45-67890";
+        String digitsOnlyCompRegNo = "1234567890";
+        PortalOrg org = org();
+        when(portalOrgRepository.findByCompRegNo(hyphenatedCompRegNo)).thenReturn(Optional.empty());
+        when(portalOrgRepository.findByCompRegNo(digitsOnlyCompRegNo)).thenReturn(Optional.of(org));
+        when(portalUserRepository.findAllByPortalOrg_Id(ORG_ID)).thenReturn(Collections.emptyList());
+        when(webhookRequestRepository.findByOrgId(ORG_ID)).thenReturn(Optional.empty());
+
+        TestCleanupResult result = service.deleteOrgCascade(hyphenatedCompRegNo);
+
+        assertTrue(result.isFound());
+        assertEquals(ORG_ID, result.getTargetId());
+        verify(portalOrgRepository).findByCompRegNo(digitsOnlyCompRegNo);
+        verify(portalOrgRepository).delete(org);
+    }
+
     @Test
     void deleteOrgCascade_found_cascadesUsersAndOrg() {
         PortalOrg org = org();
@@ -153,6 +174,58 @@ class TestCleanupServiceTest {
         assertTrue(result.getDeletedCounts().isEmpty());
     }
 
+    @Test
+    void checkUserExists_found_doesNotDeleteData() {
+        when(portalUserRepository.findPortalUserByEmailAddr(EMAIL)).thenReturn(Optional.of(user()));
+
+        TestCleanupResult result = service.checkUserExists(EMAIL);
+
+        assertTrue(result.isFound());
+        assertEquals(USER_ID, result.getTargetId());
+        assertTrue(result.getDeletedCounts().isEmpty());
+        verify(portalUserRepository, never()).delete(org.mockito.ArgumentMatchers.any(PortalUser.class));
+    }
+
+    @Test
+    void checkUserExists_notFound() {
+        when(portalUserRepository.findPortalUserByEmailAddr(EMAIL)).thenReturn(Optional.empty());
+
+        TestCleanupResult result = service.checkUserExists(EMAIL);
+
+        assertFalse(result.isFound());
+        assertTrue(result.getDeletedCounts().isEmpty());
+    }
+
+    @Test
+    void deleteInvitationsByMobile_normalizesAndDeletesAllMatches() {
+        when(userInvitationRepository.deleteByInvitationMobile("010-1234-5678")).thenReturn(2L);
+
+        TestCleanupResult result = service.deleteInvitationsByMobile("01012345678");
+
+        assertTrue(result.isFound());
+        assertEquals("010-1234-5678", result.getTargetId());
+        assertEquals(2L, result.getDeletedCounts().get("PTL_USER_INVITATION"));
+        verify(userInvitationRepository).deleteByInvitationMobile("010-1234-5678");
+    }
+
+    @Test
+    void detachUsersFromOrgByMobile_keepsUserAndRemovesOnlyMembership() {
+        PortalUser target = user();
+        target.setPortalOrg(org());
+        when(portalUserRepository.findAllByMobileNumber("010-1234-5678"))
+            .thenReturn(Collections.singletonList(target));
+
+        TestCleanupResult result = service.detachUsersFromOrgByMobile("01012345678");
+
+        assertTrue(result.isFound());
+        assertEquals(USER_ID, result.getTargetId());
+        assertEquals(1L, result.getDeletedCounts().get("PTL_USER_ORG_MEMBERSHIP"));
+        assertNull(target.getPortalOrg());
+        assertEquals(com.eactive.apim.portal.portaluser.entity.PortalUserEnums.RoleCode.ROLE_USER, target.getRoleCode());
+        verify(portalUserRepository).save(target);
+        verify(portalUserRepository, never()).delete(target);
+    }
+
     @Test
     void deleteUserCascade_found_deletesOrphanDataAndUser() {
         PortalUser target = user();