diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmService.java index d7329ea5..b53c1d68 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmService.java @@ -57,21 +57,27 @@ public void recordLog(String messageKey, Object... args) { /** * 사용자 안내: 메일과 Slack DM으로 보내고, 보냈다는 기록(본문 없음)을 알림 기록 채널에 남긴다. * 메일이 실패하면 기록 대신 오류 채널로 알린다. DM은 메일 성패와 상관없이 보낸다. + * + * @return 메일이 나갔으면 true. 호출부가 실패를 보고 다시 보내거나 중복 표시를 풀 수 있게 한다. */ - public void notifyUser(String username, String email, String subject, String body) { - safely("사용자 안내", () -> { + public boolean notifyUser(String username, String email, String subject, String body) { + try { queue.dm(username, email, body); - mailUser(username, email, subject, body); - }); + return mailUser(username, email, subject, body); + } catch (Exception e) { + log.error("사용자 안내 전송 실패", e); + return false; + } } /** 메일만 보내는 안내(접속 정보처럼 DM으로 보내지 않는 것). 발송 기록 규칙은 {@link #notifyUser}와 같다. */ - public void mailUser(String username, String email, String subject, String body) { + public boolean mailUser(String username, String email, String subject, String body) { if (mailer.send(email, subject, body)) { queue.webhook(render("notification.monitor.log", username, email, subject), channels.notiWebhookUrl()); - } else { - alertNeedsAction("notification.admin.mail-failed", EmailAddresses.mask(email)); + return true; } + alertNeedsAction("notification.admin.mail-failed", EmailAddresses.mask(email)); + return false; } /** diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/groups/controller/AdminGroupLeaveController.java b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/controller/AdminGroupLeaveController.java new file mode 100644 index 00000000..32dfe19c --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/controller/AdminGroupLeaveController.java @@ -0,0 +1,39 @@ +package DGU_AI_LAB.admin_be.domain.groups.controller; + +import DGU_AI_LAB.admin_be.domain.groups.dto.response.GroupLeaveResponseDTO; +import DGU_AI_LAB.admin_be.domain.groups.service.GroupLeaveService; +import DGU_AI_LAB.admin_be.global.auth.CustomUserDetails; +import DGU_AI_LAB.admin_be.global.common.SuccessResponse; +import lombok.RequiredArgsConstructor; +import org.springframework.http.ResponseEntity; +import org.springframework.security.core.annotation.AuthenticationPrincipal; +import org.springframework.web.bind.annotation.*; + +/** 관리자가 그룹 탈퇴 신청을 승인·거절한다. 승인하면 그룹 제거 작업이 등록된다. */ +@RestController +@RequiredArgsConstructor +@RequestMapping("/api/admin/group-leave-requests") +public class AdminGroupLeaveController { + + private final GroupLeaveService groupLeaveService; + + /** GET /api/admin/group-leave-requests — 승인을 기다리는 신청. */ + @GetMapping + public ResponseEntity> pending() { + return SuccessResponse.ok(groupLeaveService.pending().stream().map(GroupLeaveResponseDTO::fromEntity).toList()); + } + + @PostMapping("/{leaveRequestId}/approval") + public ResponseEntity> approve(@PathVariable Long leaveRequestId, + @AuthenticationPrincipal CustomUserDetails principal) { + return SuccessResponse.accepted(GroupLeaveResponseDTO.fromEntity( + groupLeaveService.approve(leaveRequestId, principal.getUserId()))); + } + + @PostMapping("/{leaveRequestId}/rejection") + public ResponseEntity> reject(@PathVariable Long leaveRequestId, + @AuthenticationPrincipal CustomUserDetails principal) { + return SuccessResponse.ok(GroupLeaveResponseDTO.fromEntity( + groupLeaveService.reject(leaveRequestId, principal.getUserId()))); + } +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/groups/controller/GroupLeaveController.java b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/controller/GroupLeaveController.java new file mode 100644 index 00000000..f746f0bc --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/controller/GroupLeaveController.java @@ -0,0 +1,34 @@ +package DGU_AI_LAB.admin_be.domain.groups.controller; + +import DGU_AI_LAB.admin_be.domain.groups.dto.response.GroupLeaveResponseDTO; +import DGU_AI_LAB.admin_be.domain.groups.service.GroupLeaveService; +import DGU_AI_LAB.admin_be.global.auth.CustomUserDetails; +import DGU_AI_LAB.admin_be.global.common.SuccessResponse; +import lombok.RequiredArgsConstructor; +import org.springframework.http.ResponseEntity; +import org.springframework.security.core.annotation.AuthenticationPrincipal; +import org.springframework.web.bind.annotation.*; + +/** 사용자가 그룹 탈퇴를 신청하고 자기 신청을 본다. 승인·거절은 {@link AdminGroupLeaveController}. */ +@RestController +@RequiredArgsConstructor +@RequestMapping("/api/groups") +public class GroupLeaveController { + + private final GroupLeaveService groupLeaveService; + + /** POST /api/groups/{groupId}/leave-requests — 속한 그룹의 탈퇴를 신청한다(승인 대기). */ + @PostMapping("/{groupId}/leave-requests") + public ResponseEntity> request(@PathVariable Long groupId, + @AuthenticationPrincipal CustomUserDetails principal) { + return SuccessResponse.created(GroupLeaveResponseDTO.fromEntity( + groupLeaveService.request(principal.getUserId(), groupId))); + } + + /** GET /api/groups/leave-requests/me — 내 탈퇴 신청 내역. */ + @GetMapping("/leave-requests/me") + public ResponseEntity> mine(@AuthenticationPrincipal CustomUserDetails principal) { + return SuccessResponse.ok(groupLeaveService.mine(principal.getUserId()).stream() + .map(GroupLeaveResponseDTO::fromEntity).toList()); + } +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/groups/dto/response/GroupLeaveResponseDTO.java b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/dto/response/GroupLeaveResponseDTO.java new file mode 100644 index 00000000..0ddb51a1 --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/dto/response/GroupLeaveResponseDTO.java @@ -0,0 +1,38 @@ +package DGU_AI_LAB.admin_be.domain.groups.dto.response; + +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveRequest; +import io.swagger.v3.oas.annotations.media.Schema; + +import java.time.LocalDateTime; + +@Schema(description = "그룹 탈퇴 신청") +public record GroupLeaveResponseDTO( + @Schema(description = "탈퇴 신청 번호", example = "3") + Long leaveRequestId, + @Schema(description = "PENDING(승인 대기) / APPROVED(승인 — 제거 작업 등록. 작업 결과는 그룹 작업 기록에서 본다) / REJECTED(거절)", example = "PENDING") + String status, + @Schema(description = "신청한 사용자 번호", example = "7") + Long userId, + @Schema(description = "신청한 사용자 이름", example = "홍길동") + String userName, + @Schema(description = "나가려는 그룹 번호", example = "12") + Long groupId, + @Schema(description = "나가려는 그룹 이름", example = "vision-lab") + String groupName, + @Schema(description = "신청 시각") + LocalDateTime createdAt, + @Schema(description = "승인·거절 시각. 대기 중이면 null") + LocalDateTime decidedAt +) { + public static GroupLeaveResponseDTO fromEntity(GroupLeaveRequest request) { + return new GroupLeaveResponseDTO( + request.getGroupLeaveRequestId(), + request.getStatus().name(), + request.getUser().getUserId(), + request.getUser().getName(), + request.getGroup().getGroupId(), + request.getGroup().getGroupName(), + request.getCreatedAt(), + request.getDecidedAt()); + } +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/groups/entity/GroupLeaveRequest.java b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/entity/GroupLeaveRequest.java new file mode 100644 index 00000000..36f58d7c --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/entity/GroupLeaveRequest.java @@ -0,0 +1,70 @@ +package DGU_AI_LAB.admin_be.domain.groups.entity; + +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.global.common.BaseTimeEntity; +import jakarta.persistence.*; +import lombok.AccessLevel; +import lombok.Getter; +import lombok.NoArgsConstructor; + +import java.time.LocalDateTime; + +/** + * 사용자가 낸 그룹 탈퇴 신청 한 건. 소속은 신청만으로 바뀌지 않는다 — 관리자가 승인하면 그룹 제거 작업이 등록되고 + * 그 작업이 성공해야 소속이 빠진다({@code GroupOperationService#requestRemove}). + */ +@Entity +@Getter +@Table(name = "group_leave_requests") +@NoArgsConstructor(access = AccessLevel.PROTECTED) +public class GroupLeaveRequest extends BaseTimeEntity { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name = "group_leave_request_id") + private Long groupLeaveRequestId; + + @Enumerated(EnumType.STRING) + @Column(name = "status", nullable = false, length = 20) + private GroupLeaveStatus status = GroupLeaveStatus.PENDING; + + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "user_id", nullable = false) + private User user; + + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "group_id", nullable = false) + private Group group; + + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "decided_by") + private User decidedBy; + + @Column(name = "decided_at") + private LocalDateTime decidedAt; + + public static GroupLeaveRequest pending(User user, Group group) { + GroupLeaveRequest request = new GroupLeaveRequest(); + request.user = user; + request.group = group; + return request; + } + + public boolean isPending() { + return status == GroupLeaveStatus.PENDING; + } + + public void approve(User admin) { + decide(GroupLeaveStatus.APPROVED, admin); + } + + public void reject(User admin) { + decide(GroupLeaveStatus.REJECTED, admin); + } + + private void decide(GroupLeaveStatus decision, User admin) { + this.status = decision; + this.decidedBy = admin; + this.decidedAt = LocalDateTime.now(); + } +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/groups/entity/GroupLeaveStatus.java b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/entity/GroupLeaveStatus.java new file mode 100644 index 00000000..cf8e37f0 --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/entity/GroupLeaveStatus.java @@ -0,0 +1,8 @@ +package DGU_AI_LAB.admin_be.domain.groups.entity; + +/** 그룹 탈퇴 신청의 상태. PENDING → APPROVED(제거 작업 등록) 또는 REJECTED. */ +public enum GroupLeaveStatus { + PENDING, + APPROVED, + REJECTED +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/groups/repository/GroupLeaveRequestRepository.java b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/repository/GroupLeaveRequestRepository.java new file mode 100644 index 00000000..a4cc2da8 --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/repository/GroupLeaveRequestRepository.java @@ -0,0 +1,27 @@ +package DGU_AI_LAB.admin_be.domain.groups.repository; + +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveRequest; +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveStatus; +import jakarta.persistence.LockModeType; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Lock; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; + +import java.util.List; +import java.util.Optional; + +public interface GroupLeaveRequestRepository extends JpaRepository { + + @Lock(LockModeType.PESSIMISTIC_WRITE) + @Query("SELECT r FROM GroupLeaveRequest r WHERE r.groupLeaveRequestId = :id") + Optional findByIdForUpdate(@Param("id") Long id); + + boolean existsByUser_UserIdAndGroup_GroupIdAndStatus(Long userId, Long groupId, GroupLeaveStatus status); + + @Query("SELECT r FROM GroupLeaveRequest r JOIN FETCH r.user JOIN FETCH r.group WHERE r.status = :status ORDER BY r.createdAt") + List findAllByStatusWithUserAndGroup(@Param("status") GroupLeaveStatus status); + + @Query("SELECT r FROM GroupLeaveRequest r JOIN FETCH r.user JOIN FETCH r.group WHERE r.user.userId = :userId ORDER BY r.createdAt DESC") + List findAllByUserWithGroup(@Param("userId") Long userId); +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveService.java new file mode 100644 index 00000000..e2c3b00f --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveService.java @@ -0,0 +1,102 @@ +package DGU_AI_LAB.admin_be.domain.groups.service; + +import DGU_AI_LAB.admin_be.domain.groups.entity.Group; +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveRequest; +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveStatus; +import DGU_AI_LAB.admin_be.domain.groups.repository.GroupLeaveRequestRepository; +import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository; +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; +import DGU_AI_LAB.admin_be.error.ErrorCode; +import DGU_AI_LAB.admin_be.error.exception.BusinessException; +import DGU_AI_LAB.admin_be.error.exception.EntityNotFoundException; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.hibernate.Hibernate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; + +/** + * 그룹 탈퇴 신청 → 관리자 승인. 승인하면 관리자가 직접 그룹에서 뺄 때와 같은 제거 작업({@link GroupOperationService#requestRemove})을 + * 등록한다. 신청만으로는 소속이 바뀌지 않는다. + */ +@Slf4j +@Service +@RequiredArgsConstructor +public class GroupLeaveService { + + private final GroupLeaveRequestRepository leaveRepository; + private final GroupRepository groupRepository; + private final UserRepository userRepository; + private final GroupOperationService groupOperationService; + + @Transactional + public GroupLeaveRequest request(Long userId, Long groupId) { + // 같은 사용자의 동시 신청이 중복 대기 신청을 만들지 못하게 사용자 행을 잠근다. + User user = userRepository.findByIdForUpdate(userId) + .orElseThrow(() -> new EntityNotFoundException(ErrorCode.USER_NOT_FOUND)); + Group group = groupRepository.findById(groupId) + .orElseThrow(() -> new EntityNotFoundException(ErrorCode.GROUP_NOT_FOUND)); + boolean member = user.getUserGroups().stream().anyMatch(ug -> ug.getGroup().getGroupId().equals(groupId)); + if (!member) { + throw new BusinessException(ErrorCode.GROUP_LEAVE_NOT_MEMBER); + } + // 기본 그룹(계정 이름과 같은 그룹)은 어차피 제거할 수 없다 — 승인까지 기다리게 하지 않고 접수에서 거절한다. + if (group.getGroupName().equals(user.getUbuntuUsername())) { + throw new BusinessException(ErrorCode.PRIMARY_GROUP_REMOVAL); + } + if (leaveRepository.existsByUser_UserIdAndGroup_GroupIdAndStatus(userId, groupId, GroupLeaveStatus.PENDING)) { + throw new BusinessException(ErrorCode.GROUP_LEAVE_ALREADY_REQUESTED); + } + GroupLeaveRequest saved = leaveRepository.save(GroupLeaveRequest.pending(user, group)); + log.info("[groupLeave] 탈퇴 신청: userId={}, groupId={}", userId, groupId); + return saved; + } + + @Transactional(readOnly = true) + public List mine(Long userId) { + return leaveRepository.findAllByUserWithGroup(userId); + } + + @Transactional(readOnly = true) + public List pending() { + return leaveRepository.findAllByStatusWithUserAndGroup(GroupLeaveStatus.PENDING); + } + + /** + * 승인하고 제거 작업을 등록한다. 신청 행을 잠근 채 확인(대기) → 제거 작업 등록 → 승인 기록을 한 트랜잭션에서 한다. + * 등록이 실패하면 아무것도 바뀌지 않고 신청은 대기로 남는다. 등록 뒤 커밋이 실패하면 작업 기록(GroupOperation)도 함께 + * 롤백돼 config-server 쪽 작업만 남고 폴러가 결과를 반영하지 못한다. 재승인하면 같은 제거 작업을 한 번 더 등록하므로 + * 제거가 멱등이어야 한다(config-server 확인 필요, 미확인). + */ + @Transactional + public GroupLeaveRequest approve(Long leaveRequestId, Long adminId) { + GroupLeaveRequest request = lockPending(leaveRequestId); + groupOperationService.requestRemove(request.getUser().getUserId(), request.getGroup().getGroupId(), adminId); + request.approve(userRepository.getReferenceById(adminId)); + log.info("[groupLeave] 탈퇴 승인: leaveRequestId={}, adminId={}", leaveRequestId, adminId); + return request; + } + + @Transactional + public GroupLeaveRequest reject(Long leaveRequestId, Long adminId) { + GroupLeaveRequest request = lockPending(leaveRequestId); + request.reject(userRepository.getReferenceById(adminId)); + log.info("[groupLeave] 탈퇴 거절: leaveRequestId={}, adminId={}", leaveRequestId, adminId); + return request; + } + + private GroupLeaveRequest lockPending(Long leaveRequestId) { + GroupLeaveRequest request = leaveRepository.findByIdForUpdate(leaveRequestId) + .orElseThrow(() -> new EntityNotFoundException(ErrorCode.GROUP_LEAVE_REQUEST_NOT_FOUND)); + if (!request.isPending()) { + throw new BusinessException(ErrorCode.INVALID_REQUEST_STATUS); + } + // 컨트롤러가 트랜잭션 밖에서 이름을 읽으므로(open-in-view 꺼짐) 지금 불러 둔다. + Hibernate.initialize(request.getUser()); + Hibernate.initialize(request.getGroup()); + return request; + } +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupMembershipPolicy.java b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupMembershipPolicy.java new file mode 100644 index 00000000..226b591a --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupMembershipPolicy.java @@ -0,0 +1,32 @@ +package DGU_AI_LAB.admin_be.domain.groups.service; + +import DGU_AI_LAB.admin_be.domain.groups.entity.Group; +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.error.ErrorCode; +import DGU_AI_LAB.admin_be.error.exception.BusinessException; +import org.springframework.stereotype.Component; + +import java.util.Collection; +import java.util.Set; +import java.util.stream.Collectors; + +/** 한 사람이 속할 수 있는 공용 그룹 수의 한도. 새로 소속이 늘어나는 경로(신청서·그룹 추가 변경 요청)가 같은 규칙을 쓴다. */ +@Component +public class GroupMembershipPolicy { + + static final int MAX_GROUPS_PER_USER = 5; + + /** + * 지금 속한 그룹에 {@code groupsToJoin}을 더해도 한도 안인지 확인한다. 이미 속한 그룹은 새로 세지 않는다. + * + * @throws BusinessException 한도를 넘으면 GROUP_LIMIT_EXCEEDED + */ + public void requireRoomFor(User user, Collection groupsToJoin) { + Set current = user.getUserGroups().stream() + .map(ug -> ug.getGroup().getGroupId()).collect(Collectors.toSet()); + long added = groupsToJoin.stream().map(Group::getGroupId).filter(id -> !current.contains(id)).distinct().count(); + if (added > 0 && current.size() + added > MAX_GROUPS_PER_USER) { + throw new BusinessException(ErrorCode.GROUP_LIMIT_EXCEEDED); + } + } +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupOperationService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupOperationService.java index afe6b377..33636936 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupOperationService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupOperationService.java @@ -74,6 +74,7 @@ public class GroupOperationService { private final UserGuideMailer userGuideMailer; private final ObjectMapper objectMapper; private final PlatformTransactionManager transactionManager; + private final GroupMembershipPolicy groupMembershipPolicy; /** 작업이 끝난 뒤(트랜잭션 밖에서) 보낼 안내. */ private record AddedNotice(ChangeRequest changeRequest, List groupNames, ChangeRequestDecision decision) {} @@ -85,7 +86,10 @@ private record FailureNotice(Long changeRequestId, String serverName, String use * 호출자의 트랜잭션 안에서 불러야 한다 — 변경 요청과 원본 신청을 잠그고 검증한 그 트랜잭션이다. */ public void startAdd(ChangeRequest changeRequest, Request originalRequest, User admin, String adminComment) { - List groupNames = groupsOf(changeRequest).stream().map(Group::getGroupName).toList(); + Set groups = groupsOf(changeRequest); + // 접수 뒤에 다른 변경 요청이 먼저 승인됐을 수 있어 승인 때 한도를 다시 확인한다. + groupMembershipPolicy.requireRoomFor(originalRequest.getUser(), groups); + List groupNames = groups.stream().map(Group::getGroupName).toList(); GroupOperation operation = operationRepository.save(GroupOperation.add( changeRequest, originalRequest.getUser(), originalRequest.getUbuntuUsername(), admin)); operation.registered(jobClient.registerGroupChange(GroupChangeRegisterRequestDTO.add( diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/home/service/HomeRetentionPolicy.java b/src/main/java/DGU_AI_LAB/admin_be/domain/home/service/HomeRetentionPolicy.java index 71e0829a..009cde5d 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/home/service/HomeRetentionPolicy.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/home/service/HomeRetentionPolicy.java @@ -40,6 +40,11 @@ public LocalDate announcedDeletionDate(LocalDate containerEndDate) { return containerEndDate.plusDays(announcedDays); } + /** 안내한 삭제일이 {@code announcedDeletionDate}인 계정의 마지막 컨테이너가 끝난 날. */ + public LocalDate containerEndDateFor(LocalDate announcedDeletionDate) { + return announcedDeletionDate.minusDays(announcedDays); + } + /** 마지막 컨테이너가 이 시각보다 먼저 끝난 계정의 홈은 지울 수 있다. */ public LocalDateTime deletableEndedBefore(LocalDateTime now) { return now.minusDays(deleteDays); diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/controller/AdminRequestController.java b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/controller/AdminRequestController.java index 470c36e0..bcf94fe3 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/controller/AdminRequestController.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/controller/AdminRequestController.java @@ -6,6 +6,9 @@ import DGU_AI_LAB.admin_be.domain.requests.dto.request.ApproveRequestDTO; import DGU_AI_LAB.admin_be.domain.requests.dto.request.RejectRequestDTO; import DGU_AI_LAB.admin_be.domain.requests.dto.request.RestartPodRequestDTO; +import DGU_AI_LAB.admin_be.error.ErrorCode; +import DGU_AI_LAB.admin_be.error.exception.BusinessException; +import org.springframework.security.core.annotation.AuthenticationPrincipal; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.GetMapping; @@ -82,9 +85,13 @@ public ResponseEntity> getAllActiveContainers( @PostMapping("/{requestId}/approval") public ResponseEntity> approveRequest(@PathVariable Long requestId, + @AuthenticationPrincipal(expression = "userId") Long adminUserId, @RequestBody @Valid ApprovalRequestDTO dto) { + if (adminUserId == null) { // 지도교수 승인 확인 기록은 승인한 관리자가 있어야 남는다. 비우면 조용히 빠진다. + throw new BusinessException(ErrorCode.UNAUTHORIZED); + } SaveRequestResponseDTO responseDto = adminRequestCommandService.approveRequest( - new ApproveRequestDTO(requestId, dto.imageId(), dto.resourceGroupId(), dto.adminComment())); + new ApproveRequestDTO(requestId, dto.imageId(), dto.resourceGroupId(), dto.adminComment(), adminUserId)); return SuccessResponse.accepted(responseDto); } diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/controller/docs/AdminRequestApi.java b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/controller/docs/AdminRequestApi.java index 59258b4c..334464d1 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/controller/docs/AdminRequestApi.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/controller/docs/AdminRequestApi.java @@ -61,7 +61,7 @@ record ContainerListResponseDoc(int status, String message, List> approveRequest(Long requestId, ApprovalRequestDTO dto); + ResponseEntity> approveRequest(Long requestId, @Parameter(hidden = true) Long adminUserId, ApprovalRequestDTO dto); @Operation(summary = "사용 신청 거절", description = "PENDING 또는 FULFILLED 상태의 신청을 거절 처리합니다.") @ApiResponse(responseCode = "200", description = "성공") diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/ApprovalRequestDTO.java b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/ApprovalRequestDTO.java index d69709b6..ef9d9fb8 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/ApprovalRequestDTO.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/ApprovalRequestDTO.java @@ -1,5 +1,6 @@ package DGU_AI_LAB.admin_be.domain.requests.dto.request; +import jakarta.validation.constraints.AssertTrue; import jakarta.validation.constraints.NotNull; import jakarta.validation.constraints.Size; @@ -11,5 +12,8 @@ public record ApprovalRequestDTO( Integer resourceGroupId, // requests.admin_comment가 300자다. @Size(max = 300, message = "승인 코멘트는 300자 이하여야 합니다.") - String adminComment + String adminComment, + @NotNull(message = "지도교수 승인 확인은 필수로 입력해야 합니다.") + @AssertTrue(message = "지도교수 승인을 확인한 뒤에만 승인할 수 있습니다.") + Boolean professorApprovalConfirmed ) {} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/ApproveRequestDTO.java b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/ApproveRequestDTO.java index 8f5290d7..62e9a890 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/ApproveRequestDTO.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/ApproveRequestDTO.java @@ -22,5 +22,12 @@ public record ApproveRequestDTO( // requests.admin_comment가 300자다. @Schema(description = "관리자 승인 코멘트 (선택 사항)", example = "사용 목적에 따라 리소스를 할당함") @Size(max = 300, message = "승인 코멘트는 300자 이하여야 합니다.") - String adminComment -) {} + String adminComment, + + // 지도교수 승인을 확인하고 승인한 관리자. 비어 있으면 지도교수 승인 확인을 기록하지 않는다(테스트 Pod 자동 승인). + Long professorApprovedByAdminId +) { + public ApproveRequestDTO(Long requestId, Long imageId, Integer resourceGroupId, String adminComment) { + this(requestId, imageId, resourceGroupId, adminComment, null); + } +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/entity/Request.java b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/entity/Request.java index 9767a0f9..0bb34df3 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/entity/Request.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/entity/Request.java @@ -46,6 +46,13 @@ public class Request extends BaseTimeEntity { @Column(name = "approved_at") private LocalDateTime approvedAt; + /** 지도교수 승인을 확인하고 승인한 관리자(users.user_id). 확인 기록이 없는 신청(이전 승인·테스트 Pod)은 비어 있다. */ + @Column(name = "professor_approval_confirmed_by") + private Long professorApprovalConfirmedBy; + + @Column(name = "professor_approval_confirmed_at") + private LocalDateTime professorApprovalConfirmedAt; + /** * 거절 사유 등, status에 대한 설명 */ @@ -158,6 +165,8 @@ public void revertToPending() { this.podName = null; this.nodeName = null; this.jobId = null; + // 실패로 돌아온 승인의 확인 기록을 지워야 다음에 승인하는 관리자가 기록된다. + clearProfessorApprovalConfirmation(); } /** @@ -175,6 +184,23 @@ public void prepareAsyncApproval(ContainerImage image, ResourceGroup resourceGro } } + /** + * 관리자가 지도교수 승인을 확인했다는 기록을 남긴다. 같은 승인 시도 안에서는 처음 기록을 덮어쓰지 않는다. + * 승인이 실패해 대기로 돌아가거나 거절되면 기록을 지운다({@link #revertToPending}, {@link #reject}). + */ + public void confirmProfessorApproval(Long adminUserId) { + if (this.professorApprovalConfirmedBy != null) { + return; + } + this.professorApprovalConfirmedBy = adminUserId; + this.professorApprovalConfirmedAt = LocalDateTime.now(); + } + + private void clearProfessorApprovalConfirmation() { + this.professorApprovalConfirmedBy = null; + this.professorApprovalConfirmedAt = null; + } + /** 이미지를 바꿔 다시 만든 작업이 성공했을 때 신청의 이미지를 새 Pod가 쓰는 이미지로 맞춘다. */ public void changeContainerImage(ContainerImage image) { this.containerImage = image; diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandService.java index 7f9d6b88..be0d7ac2 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandService.java @@ -143,6 +143,9 @@ public SaveRequestResponseDTO approveRequest(ApproveRequestDTO dto) { ResourceGroup resourceGroup = resourceGroupRepository.findById(dto.resourceGroupId()) .orElseThrow(() -> new BusinessException(ErrorCode.RESOURCE_NOT_FOUND)); req.prepareAsyncApproval(image, resourceGroup, dto.adminComment()); + if (dto.professorApprovedByAdminId() != null) { + req.confirmProfessorApproval(dto.professorApprovedByAdminId()); + } // 비밀번호 재설정 승인과 같은 사용자 행 잠금으로 직렬화한다 — 잠금 없이 읽으면 교체 직전의 옛 해시로 // 계정이 만들어질 수 있다(재설정 승인은 PROCESSING 신청이 있으면 거절한다). diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/RequestCommandService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/RequestCommandService.java index ff4bf85e..af2d4b14 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/RequestCommandService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/RequestCommandService.java @@ -8,6 +8,7 @@ import DGU_AI_LAB.admin_be.domain.containerImage.repository.ContainerImageRepository; import DGU_AI_LAB.admin_be.domain.groups.entity.Group; import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository; +import DGU_AI_LAB.admin_be.domain.groups.service.GroupMembershipPolicy; import DGU_AI_LAB.admin_be.domain.groups.service.PendingGroupService; import DGU_AI_LAB.admin_be.domain.requests.dto.request.SingleChangeRequestDTO; import DGU_AI_LAB.admin_be.domain.requests.dto.response.ChangeRequestResponseDTO; @@ -29,6 +30,7 @@ import DGU_AI_LAB.admin_be.domain.warnings.service.SuspensionGuard; import DGU_AI_LAB.admin_be.error.ErrorCode; import DGU_AI_LAB.admin_be.error.exception.BusinessException; +import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import jakarta.persistence.EntityManager; import lombok.RequiredArgsConstructor; @@ -62,6 +64,7 @@ public class RequestCommandService { private final SlackMembershipGate slackMembershipGate; private final EntityManager entityManager; private final PendingGroupService pendingGroupService; + private final GroupMembershipPolicy groupMembershipPolicy; private final HomeCleanupService homeCleanupService; /** 아직 승인·거절이 정해지지 않은 신청 상태. */ @@ -166,12 +169,29 @@ public ChangeRequestResponseDTO createSingleChangeRequest(Long userId, SingleCha // DTO 팩토리 메서드를 사용하여 검증된 ChangeRequest 생성 및 저장 ChangeRequest changeRequest = SingleChangeRequestDTO.createValidatedChangeRequest( dto, originalRequest, requestedBy, portRequestService.getPortRequestsByRequestId(requestId), objectMapper); + if (dto.changeType() == ChangeType.GROUP) { + // 값 형식은 위 검증이 끝냈다. 승인되면 이 그룹들에 속하게 되므로 한도를 먼저 확인한다. + Set gids = parseGids(dto.newValue()); + List groups = groupRepository.findAllByUbuntuGidIn(gids); + if (groups.size() != gids.size()) { // 없는 gid를 버리면 한도가 적게 계산돼 접수만 통과한다 + throw new BusinessException(ErrorCode.RESOURCE_NOT_FOUND); + } + groupMembershipPolicy.requireRoomFor(requestedBy, groups); + } changeRequestRepository.save(changeRequest); notifyChangeRequestedAfterCommit(changeRequest); return ChangeRequestResponseDTO.fromEntity(changeRequest); } + private Set parseGids(String newValue) { + try { + return objectMapper.readValue(newValue, objectMapper.getTypeFactory().constructCollectionType(Set.class, Long.class)); + } catch (JsonProcessingException e) { + throw new BusinessException("새로운 값의 형식이 올바르지 않습니다.", ErrorCode.INVALID_INPUT_VALUE); + } + } + /** * 변경 요청이 들어왔음을 알린다. 값은 지금(트랜잭션 안에서) 읽고 전송만 커밋 뒤로 미룬다. * 알림 실패는 접수를 실패시키지 않는다. @@ -264,6 +284,8 @@ public SaveRequestResponseDTO createRequest(Long userId, SaveRequestRequestDTO d } List groups = findChosenGroups(dto); + // 신청이 승인되면 고른 그룹에 속하게 된다 — 지금 속한 그룹과 합쳐 한도를 넘으면 받지 않는다. + groupMembershipPolicy.requireRoomFor(user, groups); // 입력이 잘못돼 거절된 요청은 하루 한도에서 빼려고 모든 검증 뒤에 센다. Redis 카운터는 트랜잭션과 함께 // 되돌아가지 않으므로, 이 아래에는 입력 때문에 실패하는 검증을 두지 않는다. diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderScheduler.java b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderScheduler.java new file mode 100644 index 00000000..65de3151 --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderScheduler.java @@ -0,0 +1,132 @@ +package DGU_AI_LAB.admin_be.domain.scheduler; + +import DGU_AI_LAB.admin_be.domain.alarm.service.AlarmService; +import DGU_AI_LAB.admin_be.domain.home.service.HomeRetentionPolicy; +import DGU_AI_LAB.admin_be.domain.requests.entity.Status; +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; +import DGU_AI_LAB.admin_be.global.util.MessageUtils; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.data.redis.core.RedisTemplate; +import org.springframework.scheduling.annotation.Scheduled; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.Duration; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.temporal.ChronoUnit; +import java.util.List; +import java.util.Optional; + +/** + * 사용자에게 안내한 홈 삭제일의 7일 전과 1일 전에 메일·Slack DM으로 다시 알린다. 삭제일은 컨테이너가 끝날 때 한 번 + * 안내했지만, 한 달 가까이 지나 잊기 쉽다. 실제 삭제는 안내한 날보다 늦으므로({@link HomeRetentionPolicy}) 이 안내를 + * 받고 새로 신청할 시간이 있다. 삭제 작업({@link HomeCleanupScheduler})보다 먼저 돈다. + * + *

대상은 "삭제일이 오늘 뒤 7일 안에 든 계정"이다 — 실행이 며칠 빠져도 창 안에 남아 있으면 다음 실행에서 따라잡는다. + * 한 사용자는 하루에 한 단계만 받는다(남은 날이 2~7일이면 7일 단계, 1일이면 1일 단계). 삭제일 당일 이후는 보내지 않는다. + * 같은 주기·같은 단계는 Redis 키로 한 번만 보내고, 발송이 실패하면 키를 풀어 다음 실행에서 다시 보낸다. + */ +@Slf4j +@Service +@RequiredArgsConstructor +public class HomeDeletionReminderScheduler { + + /** 삭제일까지 남은 일수 중 안내를 보내는 단계. 큰 값부터 쓴다. */ + static final List REMIND_DAYS_BEFORE = List.of(7, 1); + + /** 한 삭제 주기 동안 같은 단계를 막을 만큼 둔다(창이 닫힌 뒤에도 중복되지 않게). */ + private static final Duration CLAIM_TTL = Duration.ofDays(60); + + private final UserRepository userRepository; + private final HomeRetentionPolicy retentionPolicy; + private final AlarmService alarmService; + private final MessageUtils messageUtils; + private final RedisTemplate redisTemplate; + + // 마지막 컨테이너 종료 시각이 신청 목록(지연 로딩)을 읽으므로 실행 전체를 읽기 트랜잭션으로 묶는다. + @Transactional(readOnly = true) + @Scheduled(cron = "${home-retention.reminder-cron:0 0 9 * * ?}", zone = "Asia/Seoul") + public void run() { + remind(LocalDate.now(ZoneId.of("Asia/Seoul"))); + } + + void remind(LocalDate today) { + int window = REMIND_DAYS_BEFORE.stream().mapToInt(Integer::intValue).max().orElseThrow(); + // 삭제일 today+1 ~ today+window 에 해당하는 마지막 컨테이너 종료일 범위를 시각으로 바꾼다. + LocalDate firstEnded = retentionPolicy.containerEndDateFor(today.plusDays(1)); + LocalDate lastEnded = retentionPolicy.containerEndDateFor(today.plusDays(window)); + List users = userRepository.findHomeReminderCandidates( + firstEnded.atStartOfDay(), lastEnded.plusDays(1).atStartOfDay(), Status.openStatuses()); + for (User user : users) { + try { + remind(user, today); + } catch (Exception e) { + // 한 사용자의 실패가 나머지를 막지 않게 한다. 키는 실패 시 풀려 있어 다음 실행에서 다시 본다. + log.error("[homeReminder] 홈 삭제 안내 실패: userId={}", user.getUserId(), e); + } + } + } + + private void remind(User user, LocalDate today) { + Optional endedAt = user.lastContainerEndedAt(); + if (endedAt.isEmpty()) { + return; + } + LocalDate deletionDate = retentionPolicy.announcedDeletionDate(endedAt.get().toLocalDate()); + long daysLeft = ChronoUnit.DAYS.between(today, deletionDate); + if (daysLeft < 1 || daysLeft > REMIND_DAYS_BEFORE.get(0)) { + return; + } + String key = "email:home-delete-reminder:" + user.getUserId() + ":" + stageOf(daysLeft) + ":" + deletionDate; + if (isDuplicate(key)) { + return; + } + boolean sent; + try { + String subject = messageUtils.get("notification.user.home-delete-reminder.subject", String.valueOf(daysLeft)); + String body = messageUtils.get("notification.user.home-delete-reminder.body", + user.getName(), user.getUbuntuUsername(), String.valueOf(daysLeft), deletionDate.toString()); + sent = alarmService.notifyUser(user.getName(), user.getEmail(), subject, body); + } catch (RuntimeException e) { + release(key); + throw e; + } + if (!sent) { + release(key); + log.warn("[homeReminder] 메일 발송 실패, 다음 실행에서 다시 보냅니다: userId={}", user.getUserId()); + } + } + + /** 남은 일수를 덮는 가장 가까운 단계(예: 5일 → 7일 단계, 1일 → 1일 단계). */ + private static int stageOf(long daysLeft) { + return REMIND_DAYS_BEFORE.stream() + .filter(stage -> daysLeft <= stage) + .min(Integer::compare) + .orElseThrow(); + } + + /** + * 같은 주기·같은 단계가 이미 잡혀 있으면 true. 없으면 지금 잡고 false — 발송이 실패하면 {@link #release}로 푼다. + * Redis 장애 시에는 보내는 쪽으로 열어 둔다(fail-open). + */ + private boolean isDuplicate(String key) { + try { + return Boolean.FALSE.equals(redisTemplate.opsForValue().setIfAbsent(key, "sent", CLAIM_TTL)); + } catch (Exception e) { + log.warn("[homeReminder] Redis 중복 확인 실패, 발송 진행: {}", e.getMessage()); + return false; + } + } + + private void release(String key) { + try { + redisTemplate.delete(key); + } catch (Exception e) { + log.warn("[homeReminder] 중복 키 해제 실패(다음 실행에서 이 단계가 빠질 수 있음): {}", e.getMessage()); + } + } +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/UserLifecycleTransactionalService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/UserLifecycleTransactionalService.java index 9a6cffb8..ab5bf6e8 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/UserLifecycleTransactionalService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/UserLifecycleTransactionalService.java @@ -1,6 +1,7 @@ package DGU_AI_LAB.admin_be.domain.scheduler; import DGU_AI_LAB.admin_be.domain.alarm.service.AlarmService; +import DGU_AI_LAB.admin_be.domain.home.service.HomeRetentionPolicy; import DGU_AI_LAB.admin_be.domain.users.entity.Role; import DGU_AI_LAB.admin_be.domain.users.entity.User; import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; @@ -34,10 +35,14 @@ public class UserLifecycleTransactionalService { private final MessageUtils messageUtils; private final RedisTemplate redisTemplate; private final InactivityNoticeStore noticeStore; + private final HomeRetentionPolicy homeRetentionPolicy; /** 마지막 컨테이너가 끝난 뒤(컨테이너를 쓴 적이 없으면 가입한 뒤) 이만큼 지나면 비활성화한다. */ static final int INACTIVE_MONTHS = 12; + /** 졸업 예정일로부터 이만큼 지나면 비활성화한다. 1년 미사용 규칙과 함께 적용하고 더 이른 쪽을 따른다. */ + static final int GRADUATION_GRACE_DAYS = 30; + /** 기한이 지나도록 경고를 받지 못한 사용자에게 경고와 함께 주는 유예 기간. */ static final int NOTICE_DAYS = 7; @@ -68,7 +73,9 @@ public boolean processInactiveUser(Long userId, LocalDateTime now) { } LocalDate today = now.toLocalDate(); - LocalDate ruleDate = inactiveSince.plusMonths(INACTIVE_MONTHS).toLocalDate(); + RuleDeadline rule = ruleDeadline(user); + LocalDate ruleDate = rule.date(); + boolean byGraduation = rule.byGraduation(); LocalDate deleteDate = ruleDate.isAfter(today) ? ruleDate : noticedDeadline(userId, today); long daysLeft = ChronoUnit.DAYS.between(today, deleteDate); @@ -79,11 +86,31 @@ public boolean processInactiveUser(Long userId, LocalDateTime now) { log.warn("유저({}) 유예 예정일을 기록하지 못해 경고를 보내지 않고 다음 회차에 다시 봅니다", userId); return false; } - sendWarningAlert(user, daysLeft, deleteDate, today.toString()); + sendWarningAlert(user, daysLeft, deleteDate, today.toString(), byGraduation); } return daysLeft <= 0; } + /** + * 두 규칙(졸업 예정일 + {@link #GRADUATION_GRACE_DAYS}, 마지막 컨테이너 종료 + {@link #INACTIVE_MONTHS})의 기한과 + * 어느 쪽이 이른지. 졸업 예정일을 계속 미뤄도 1년 미사용 규칙은 피하지 못하므로 더 이른 쪽을 쓴다. + * 판정은 이 메서드만 한다 — 스케줄러 경고·비활성화와 관리자 탈퇴가 같은 결과를 쓴다. + * 미사용 기준 시각이 없으면(가입 시각도 없는 미저장 엔티티) 졸업 기한만 본다. + */ + public static RuleDeadline ruleDeadline(User user) { + LocalDateTime inactiveSince = inactiveSince(user); + LocalDate inactivityDate = inactiveSince == null ? null : inactiveSince.plusMonths(INACTIVE_MONTHS).toLocalDate(); + LocalDate graduationDate = user.getExpectedGraduationDate() == null + ? null : user.getExpectedGraduationDate().plusDays(GRADUATION_GRACE_DAYS); + boolean byGraduation = graduationDate != null + && (inactivityDate == null || graduationDate.isBefore(inactivityDate)); + return new RuleDeadline(byGraduation ? graduationDate : inactivityDate, byGraduation); + } + + /** 규칙별 기한 중 적용되는 기한과, 그것이 졸업 규칙인지. */ + public record RuleDeadline(LocalDate date, boolean byGraduation) { + } + /** 규칙상 기한이 지난 사용자의 비활성화 예정일. 경고하면서 알린 날이 있으면 그날, 없으면 오늘부터 유예를 준다. */ private LocalDate noticedDeadline(Long userId, LocalDate today) { return noticeStore.findDeadline(userId).orElseGet(() -> today.plusDays(NOTICE_DAYS)); @@ -97,16 +124,17 @@ private static LocalDateTime inactiveSince(User user) { return user.lastContainerEndedAt().orElse(user.getCreatedAt()); } - private void sendWarningAlert(User user, long daysLeft, LocalDate deleteDate, String today) { + private void sendWarningAlert(User user, long daysLeft, LocalDate deleteDate, String today, boolean byGraduation) { if (isDuplicateWarning(user.getUserId(), daysLeft, today)) { log.debug("계정 삭제 경고 중복 발송 방지: userId={}, daysLeft={}, date={}", user.getUserId(), daysLeft, today); return; } String dateStr = deleteDate.toString(); - String subject = messageUtils.get("notification.user.delete-warning.subject", String.valueOf(daysLeft)); - String body = messageUtils.get("notification.user.delete-warning.body", - user.getName(), String.valueOf(daysLeft), dateStr); + String noticeKey = byGraduation ? "notification.user.graduation-warning" : "notification.user.delete-warning"; + String subject = messageUtils.get(noticeKey + ".subject", String.valueOf(daysLeft)); + String body = messageUtils.get(noticeKey + ".body", + user.getName(), String.valueOf(daysLeft), dateStr, String.valueOf(homeRetentionPolicy.announcedDays())); String name = user.getName(); String email = user.getEmail(); diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/UserSchedulerService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/UserSchedulerService.java index c33fe946..5f012d4e 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/UserSchedulerService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/UserSchedulerService.java @@ -9,6 +9,9 @@ import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Service; +import java.time.LocalDate; +import java.util.LinkedHashMap; +import java.util.Map; import java.time.LocalDateTime; import java.time.ZoneId; import java.util.List; @@ -39,7 +42,15 @@ public void runUserLifecycleScheduler() { private void processInactiveUsers(LocalDateTime now) { LocalDateTime searchThreshold = now.plusDays(NOTIFICATION_LEAD_DAYS) .minusMonths(UserLifecycleTransactionalService.INACTIVE_MONTHS); - List inactiveCandidates = userRepository.findInactiveUsers(searchThreshold, Status.openStatuses()); + // 졸업 예정일 + 30일의 D-7 경고까지 포함하려면 졸업 예정일이 (오늘 + 8일 - 30일)보다 이른 사용자를 본다. + LocalDate graduationBefore = now.toLocalDate().plusDays(NOTIFICATION_LEAD_DAYS) + .minusDays(UserLifecycleTransactionalService.GRADUATION_GRACE_DAYS); + Map candidates = new LinkedHashMap<>(); + userRepository.findInactiveUsers(searchThreshold, Status.openStatuses()) + .forEach(u -> candidates.put(u.getUserId(), u)); + userRepository.findGraduatingUsers(graduationBefore, Status.openStatuses()) + .forEach(u -> candidates.putIfAbsent(u.getUserId(), u)); + List inactiveCandidates = List.copyOf(candidates.values()); for (User user : inactiveCandidates) { try { diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/controller/UserController.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/controller/UserController.java index 9974fa5b..2c094d47 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/controller/UserController.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/controller/UserController.java @@ -1,6 +1,7 @@ package DGU_AI_LAB.admin_be.domain.users.controller; import DGU_AI_LAB.admin_be.domain.users.controller.docs.UserApi; +import DGU_AI_LAB.admin_be.domain.users.dto.request.GraduationUpdateRequestDTO; import DGU_AI_LAB.admin_be.domain.users.dto.request.PhoneUpdateRequestDTO; import DGU_AI_LAB.admin_be.domain.users.dto.request.ContactEmailUpdateRequestDTO; import DGU_AI_LAB.admin_be.domain.users.dto.request.UbuntuUsernameRegisterRequestDTO; @@ -45,6 +46,18 @@ public ResponseEntity> updateUserPhone(@AuthenticationPrincip return SuccessResponse.ok(updatedUser); } + /** + * 졸업 예정일 입력 API + * PATCH /api/users/me/graduation + */ + @PatchMapping("/me/graduation") + public ResponseEntity> updateExpectedGraduationDate( + @AuthenticationPrincipal CustomUserDetails principal, + @RequestBody @Valid GraduationUpdateRequestDTO request + ) { + return SuccessResponse.ok(userService.updateExpectedGraduationDate(principal.getUserId(), request)); + } + /** * 내 Slack 가입 확인 결과 API — 신청하기 전에 화면이 미리 알려 주는 데 쓴다. * GET /api/users/me/slack-membership diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/controller/docs/UserApi.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/controller/docs/UserApi.java index e92ae076..8495e4a6 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/controller/docs/UserApi.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/controller/docs/UserApi.java @@ -1,5 +1,6 @@ package DGU_AI_LAB.admin_be.domain.users.controller.docs; +import DGU_AI_LAB.admin_be.domain.users.dto.request.GraduationUpdateRequestDTO; import DGU_AI_LAB.admin_be.domain.users.dto.request.PhoneUpdateRequestDTO; import DGU_AI_LAB.admin_be.domain.users.dto.request.UbuntuUsernameRegisterRequestDTO; import DGU_AI_LAB.admin_be.global.auth.CustomUserDetails; @@ -41,6 +42,18 @@ ResponseEntity> updateUserPhone( @RequestBody @Valid PhoneUpdateRequestDTO request ); + @Operation(summary = "졸업 예정일 입력", description = "졸업 예정일 + 30일이 지나면 계정이 비활성화됩니다. 가입 때 받지 못한 기존 사용자가 접속할 때 입력합니다.") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공"), + @ApiResponse(responseCode = "400", description = "잘못된 요청 (지난 날짜 등)"), + @ApiResponse(responseCode = "401", description = "인증 실패") + }) + @PatchMapping("/me/graduation") + ResponseEntity> updateExpectedGraduationDate( + @AuthenticationPrincipal @Parameter(hidden = true) CustomUserDetails principal, + @RequestBody @Valid GraduationUpdateRequestDTO request + ); + @Operation(summary = "우분투 유저네임 등록", description = "가입 시 우분투 유저네임을 받기 전에 만들어진 계정을 위한 1회성 등록 API입니다. 이미 등록되어 있으면 실패합니다.") @ApiResponses(value = { @ApiResponse(responseCode = "200", description = "성공"), diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/dto/request/GraduationUpdateRequestDTO.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/dto/request/GraduationUpdateRequestDTO.java new file mode 100644 index 00000000..84aaf776 --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/dto/request/GraduationUpdateRequestDTO.java @@ -0,0 +1,13 @@ +package DGU_AI_LAB.admin_be.domain.users.dto.request; + +import io.swagger.v3.oas.annotations.media.Schema; +import DGU_AI_LAB.admin_be.global.validation.ExpectedGraduationDate; + +import java.time.LocalDate; + +@Schema(description = "졸업 예정일 입력 요청 DTO") +public record GraduationUpdateRequestDTO( + @Schema(description = "졸업 예정일. 이 날짜 + 30일이 지나면 계정이 비활성화된다", example = "2027-02-26") + @ExpectedGraduationDate + LocalDate expectedGraduationDate +) {} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/dto/request/UserRegisterRequestDTO.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/dto/request/UserRegisterRequestDTO.java index 1c94580b..47627306 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/dto/request/UserRegisterRequestDTO.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/dto/request/UserRegisterRequestDTO.java @@ -3,6 +3,7 @@ import DGU_AI_LAB.admin_be.domain.users.entity.User; import DGU_AI_LAB.admin_be.global.validation.MaxUtf8Bytes; import DGU_AI_LAB.admin_be.global.validation.PhoneNumber; +import DGU_AI_LAB.admin_be.global.validation.ExpectedGraduationDate; import DGU_AI_LAB.admin_be.global.validation.PhoneNumbers; import DGU_AI_LAB.admin_be.global.validation.UbuntuUsername; import io.swagger.v3.oas.annotations.media.Schema; @@ -11,6 +12,8 @@ import jakarta.validation.constraints.Pattern; import jakarta.validation.constraints.Size; +import java.time.LocalDate; + @Schema(description = "회원가입 요청 DTO") public record UserRegisterRequestDTO( @@ -55,7 +58,13 @@ public record UserRegisterRequestDTO( // Slack에 학교 이메일이 아닌 주소로 가입한 사람을 알아보는 데 쓴다. 비우거나 학교 이메일과 같게 적으면 저장하지 않는다. @Schema(description = "자주 사용하는 이메일 (없거나 학교 이메일과 같으면 생략)", example = "user@gmail.com") @Email @Size(max = 100) - String contactEmail + String contactEmail, + + // 이 날짜 + 30일이 지나면 계정이 비활성화된다. 필수 입력이라 졸업 예정일이 없는 옛 가입 화면은 400을 받는다 — + // 배포할 때 BE와 FE를 함께 올려야 한다. + @Schema(description = "졸업 예정일", example = "2027-02-26") + @ExpectedGraduationDate + LocalDate expectedGraduationDate ) { /** 비밀번호는 서비스에서 암호화한 값을 넘겨서 처리 */ public User toEntity(String encodedPassword) { @@ -68,6 +77,7 @@ public User toEntity(String encodedPassword) { .phone(PhoneNumbers.normalize(phone)) .ubuntuUsername(ubuntuUsername) .contactEmail(contactEmail) + .expectedGraduationDate(expectedGraduationDate) // role, isActive는 엔티티의 @Builder.Default 로 기본값 사용 .build(); } diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/dto/response/MyInfoResponseDTO.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/dto/response/MyInfoResponseDTO.java index 08b377b6..c55c5006 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/dto/response/MyInfoResponseDTO.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/dto/response/MyInfoResponseDTO.java @@ -4,6 +4,7 @@ import DGU_AI_LAB.admin_be.domain.users.entity.User; import io.swagger.v3.oas.annotations.media.Schema; +import java.time.LocalDate; import java.time.LocalDateTime; @Schema(description = "내 정보 응답 DTO") @@ -30,6 +31,8 @@ public record MyInfoResponseDTO( Boolean isActive, @Schema(description = "사용자 권한", example = "USER", allowableValues = {"USER", "ADMIN"}) Role role, + @Schema(description = "졸업 예정일 — null이면 아직 입력하지 않은 사용자(화면이 입력을 받는다)", example = "2027-02-26") + LocalDate expectedGraduationDate, @Schema(description = "계정 생성 일시", example = "2026-01-09T15:25:28") LocalDateTime createdAt, @Schema(description = "계정 수정 일시", example = "2026-01-09T15:25:28") @@ -48,6 +51,7 @@ public static MyInfoResponseDTO fromEntity(User u) { u.hasUbuntuPassword(), u.getIsActive(), u.getRole(), + u.getExpectedGraduationDate(), u.getCreatedAt(), u.getUpdatedAt() ); diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/entity/User.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/entity/User.java index a06512a4..cd58b7be 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/entity/User.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/entity/User.java @@ -12,6 +12,7 @@ import DGU_AI_LAB.admin_be.domain.groups.entity.Group; import java.time.Instant; +import java.time.LocalDate; import java.time.LocalDateTime; import java.time.ZoneId; import java.time.temporal.ChronoUnit; @@ -112,6 +113,10 @@ public class User extends BaseTimeEntity { @Column(name = "password_changed_at") private LocalDateTime passwordChangedAt; + /** 졸업 예정일. 비어 있으면 아직 받지 못한 사용자다(마지막 컨테이너 종료 1년 규칙을 적용). */ + @Column(name = "expected_graduation_date") + private LocalDate expectedGraduationDate; + @OneToMany(mappedBy = "user", cascade = CascadeType.REMOVE, orphanRemoval = true) private List requests = new ArrayList<>(); @@ -125,7 +130,7 @@ public class User extends BaseTimeEntity { @Builder public User(String email, String password, String name, String studentId, String phone, String department, - String ubuntuUsername, String contactEmail) { + String ubuntuUsername, String contactEmail, LocalDate expectedGraduationDate) { this.email = email; this.password = password; this.name = name; @@ -134,6 +139,7 @@ public User(String email, String password, String name, String studentId, String this.department = department; this.ubuntuUsername = ubuntuUsername; this.contactEmail = distinctContactEmail(contactEmail); + this.expectedGraduationDate = expectedGraduationDate; this.lastLoginAt = LocalDateTime.now(); } @@ -157,6 +163,10 @@ public void updatePhone(String newPhone) { this.phone = newPhone; } + public void updateExpectedGraduationDate(LocalDate date) { + this.expectedGraduationDate = date; + } + /** 빈 값이나 학교 이메일과 같은 값은 "따로 없음"으로 둔다. */ public void updateContactEmail(String newContactEmail) { this.contactEmail = distinctContactEmail(newContactEmail); @@ -182,6 +192,8 @@ public void withdraw() { public void reactivate() { this.isActive = true; this.deletedAt = null; + // 졸업 예정일이 이미 지난 채 되살리면 며칠 뒤 같은 규칙으로 다시 비활성화된다. 다시 입력받는다(접속 시 모달). + this.expectedGraduationDate = null; } /** diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepository.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepository.java index 3b3bed43..c8dd0a09 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepository.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepository.java @@ -13,6 +13,7 @@ import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Transactional; +import java.time.LocalDate; import java.time.LocalDateTime; import java.util.Collection; import java.util.List; @@ -70,8 +71,8 @@ int replaceWeakUbuntuPasswordHash(@Param("userId") Long userId, @Param("hash") S /** * 장기 미사용 판정 후보. 가입 시각이 기준일보다 이르고, 끝나지 않은 신청(컨테이너 포함)이 하나도 없는 활성 일반 - * 사용자다. 관리자는 비활성화하면 운영할 사람이 사라지므로 뺀다. 미사용 기준 시각은 가입 시각보다 이르지 않아 - * 가입 시각으로 추려도 대상이 빠지지 않는다. 마지막 컨테이너가 끝난 시각까지 따진 최종 판정은 + * 사용자다. 졸업 예정일이 있어도 빼지 않는다 — 졸업 예정일을 미뤄 이 규칙을 피할 수 없다(두 규칙 중 이른 기한이 적용된다). 관리자는 비활성화하면 운영할 사람이 사라지므로 뺀다. + * 미사용 기준 시각은 가입 시각보다 이르지 않아 가입 시각으로 추려도 대상이 빠지지 않는다. 마지막 컨테이너가 끝난 시각까지 따진 최종 판정은 * UserLifecycleTransactionalService가 한 곳에서 한다. */ @Query("SELECT u FROM User u " + @@ -82,6 +83,18 @@ int replaceWeakUbuntuPasswordHash(@Param("userId") Long userId, @Param("hash") S List findInactiveUsers(@Param("thresholdDate") LocalDateTime thresholdDate, @Param("openStatuses") Collection openStatuses); + /** + * 졸업 예정일 규칙 후보. 졸업 예정일이 {@code graduationBefore}보다 이른 활성 일반 사용자 중 끝나지 않은 신청이 + * 없는 사람이다. 최종 판정(졸업 예정일 + 30일)은 UserLifecycleTransactionalService가 한다. + */ + @Query("SELECT u FROM User u " + + "WHERE u.isActive = true " + + " AND u.role <> DGU_AI_LAB.admin_be.domain.users.entity.Role.ADMIN " + + " AND u.expectedGraduationDate < :graduationBefore " + + " AND NOT EXISTS (SELECT r FROM Request r WHERE r.user = u AND r.status IN :openStatuses)") + List findGraduatingUsers(@Param("graduationBefore") LocalDate graduationBefore, + @Param("openStatuses") Collection openStatuses); + /** * 홈 삭제 후보. 리눅스 계정을 가진 적이 있고, 끝나지 않은 신청이 하나도 없고, 마지막 컨테이너가 기준 시각보다 먼저 * 끝난 사용자다. 계정이 회수됐거나 비활성화된 사용자도 홈은 남아 있으므로 포함한다. 이미 지웠는지까지 따진 최종 @@ -95,4 +108,21 @@ List findInactiveUsers(@Param("thresholdDate") LocalDateTime thresholdDate " AND d.approvedAt IS NOT NULL) < :endedBefore") List findHomeCleanupCandidates(@Param("endedBefore") LocalDateTime endedBefore, @Param("openStatuses") Collection openStatuses); + + /** + * 홈 삭제 직전 안내 후보. {@link #findHomeCleanupCandidates}와 같은 조건에, 마지막 컨테이너가 끝난 시각이 + * [from, to) 안이고 탈퇴·비활성화되지 않은 사용자다(비활성 사용자에게 "새로 신청"하라고 안내하지 않는다). + */ + @Query("SELECT u FROM User u " + + "WHERE u.ubuntuUsername IS NOT NULL AND u.ubuntuUid IS NOT NULL AND u.deletedAt IS NULL AND u.isActive = true " + + " AND NOT EXISTS (SELECT r FROM Request r WHERE r.user = u AND r.status IN :openStatuses) " + + " AND (SELECT MAX(d.updatedAt) FROM Request d WHERE d.user = u " + + " AND d.status = DGU_AI_LAB.admin_be.domain.requests.entity.Status.DELETED " + + " AND d.approvedAt IS NOT NULL) >= :from " + + " AND (SELECT MAX(d.updatedAt) FROM Request d WHERE d.user = u " + + " AND d.status = DGU_AI_LAB.admin_be.domain.requests.entity.Status.DELETED " + + " AND d.approvedAt IS NOT NULL) < :to") + List findHomeReminderCandidates(@Param("from") LocalDateTime from, + @Param("to") LocalDateTime to, + @Param("openStatuses") Collection openStatuses); } diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserService.java index 4b2f0977..d9516d35 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserService.java @@ -7,6 +7,7 @@ import DGU_AI_LAB.admin_be.domain.requests.repository.RequestRepository; import DGU_AI_LAB.admin_be.domain.requests.service.PodMigrationService; import DGU_AI_LAB.admin_be.domain.requests.service.RequestExpiryService; +import DGU_AI_LAB.admin_be.domain.scheduler.UserLifecycleTransactionalService; import DGU_AI_LAB.admin_be.domain.users.dto.response.UserSummaryDTO; import DGU_AI_LAB.admin_be.domain.users.entity.Role; import DGU_AI_LAB.admin_be.domain.users.entity.UbuntuAccountStatus; @@ -18,6 +19,7 @@ import DGU_AI_LAB.admin_be.error.exception.EntityNotFoundException; import DGU_AI_LAB.admin_be.global.util.AfterCommit; import DGU_AI_LAB.admin_be.global.util.MessageUtils; +import DGU_AI_LAB.admin_be.domain.home.service.HomeRetentionPolicy; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; @@ -27,6 +29,8 @@ import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.support.TransactionTemplate; +import java.time.LocalDate; +import java.time.ZoneId; import java.util.ArrayList; import java.util.List; import java.util.Objects; @@ -48,6 +52,7 @@ public class AdminUserService { private final PasswordResetService passwordResetService; private final InactivityNoticeStore inactivityNoticeStore; private final PlatformTransactionManager transactionManager; + private final HomeRetentionPolicy homeRetentionPolicy; /** * 전체 유저 조회 @@ -170,15 +175,30 @@ public void deleteUser(Long userId) { */ @Transactional(propagation = Propagation.NOT_SUPPORTED) public void withdrawInactiveUser(Long userId) { - User user = new TransactionTemplate(transactionManager).execute(status -> userRepository.findById(userId) - .orElseThrow(() -> new EntityNotFoundException(ErrorCode.USER_NOT_FOUND))); + // 판정(lastContainerEndedAt)이 지연 로딩 requests를 읽으므로 사용자를 읽는 트랜잭션 안에서 끝낸다. + InactiveCheck check = new TransactionTemplate(transactionManager).execute(status -> { + User found = userRepository.findById(userId) + .orElseThrow(() -> new EntityNotFoundException(ErrorCode.USER_NOT_FOUND)); + return new InactiveCheck(found, found.getIsActive() && isGraduationReason(found)); + }); + User user = check.user(); if (!user.getIsActive()) { log.info("[withdrawInactiveUser] userId={} 이미 비활성 상태라 건너뜁니다", userId); return; } requireNotLastActiveAdminInNewTx(userId); log.warn("[withdrawInactiveUser] userId={} 장기 미사용 탈퇴 시작", userId); - withdrawWithCleanup(userId, user, "withdrawInactiveUser", "notification.user.soft-delete"); + String noticeKey = check.byGraduation() ? "notification.user.soft-delete.graduation" : "notification.user.soft-delete"; + withdrawWithCleanup(userId, user, "withdrawInactiveUser", noticeKey); + } + + /** 스케줄러와 같은 규칙(두 규칙 중 이른 쪽)으로 본다. 졸업 쪽이 이르더라도 졸업 기한 전이면 졸업 사유가 아니다. */ + private static boolean isGraduationReason(User user) { + UserLifecycleTransactionalService.RuleDeadline rule = UserLifecycleTransactionalService.ruleDeadline(user); + return rule.byGraduation() && !rule.date().isAfter(LocalDate.now(ZoneId.of("Asia/Seoul"))); + } + + private record InactiveCheck(User user, boolean byGraduation) { } /** 비활성화는 이미 끝났으므로 실패해도 되돌리지 않는다 — 남은 신청은 승인이 거절한다. */ @@ -209,7 +229,7 @@ private void withdrawWithCleanup(Long userId, User user, String logPrefix, Strin AfterCommit.run("계정 비활성화 안내(" + logPrefix + "), userId " + userId, () -> { String subject = messageUtils.get(noticeKey + ".subject"); - String body = messageUtils.get(noticeKey + ".body", withdrawn.getName()); + String body = messageUtils.get(noticeKey + ".body", withdrawn.getName(), String.valueOf(homeRetentionPolicy.announcedDays())); alarmService.notifyUser(withdrawn.getName(), withdrawn.getEmail(), subject, body); }); } diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/UserService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/UserService.java index 9edfc95f..4ccb47e3 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/UserService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/UserService.java @@ -2,6 +2,7 @@ import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository; import DGU_AI_LAB.admin_be.domain.users.dto.request.ContactEmailUpdateRequestDTO; +import DGU_AI_LAB.admin_be.domain.users.dto.request.GraduationUpdateRequestDTO; import DGU_AI_LAB.admin_be.domain.users.dto.request.PhoneUpdateRequestDTO; import DGU_AI_LAB.admin_be.global.validation.PhoneNumbers; import DGU_AI_LAB.admin_be.domain.users.dto.request.UbuntuUsernameRegisterRequestDTO; @@ -65,6 +66,15 @@ public UserResponseDTO updatePhone(Long userId, PhoneUpdateRequestDTO request) { return UserResponseDTO.fromEntity(user); } + /** 졸업 예정일 입력 — 가입 때 받지 못한 기존 사용자가 접속할 때 입력한다. 바꾸는 것도 같은 경로다. */ + public UserResponseDTO updateExpectedGraduationDate(Long userId, GraduationUpdateRequestDTO request) { + User user = userRepository.findById(userId) + .orElseThrow(() -> new EntityNotFoundException(ErrorCode.USER_NOT_FOUND)); + user.updateExpectedGraduationDate(request.expectedGraduationDate()); + log.info("[updateExpectedGraduationDate] userId={} 졸업 예정일 저장", userId); + return UserResponseDTO.fromEntity(user); + } + /** 지금 신청하면 Slack 가입 확인에 걸리는지 미리 알려 준다. */ @Transactional(readOnly = true) public SlackMembershipResponseDTO getSlackMembership(Long userId) { diff --git a/src/main/java/DGU_AI_LAB/admin_be/error/ErrorCode.java b/src/main/java/DGU_AI_LAB/admin_be/error/ErrorCode.java index 13aa02c1..517a2594 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/error/ErrorCode.java +++ b/src/main/java/DGU_AI_LAB/admin_be/error/ErrorCode.java @@ -129,6 +129,10 @@ public enum ErrorCode { INVALID_GROUP_MEMBER(HttpStatus.BAD_REQUEST, "존재하지 않는 사용자입니다."), RESERVED_GROUP_NAME(HttpStatus.CONFLICT, "시스템이 이미 쓰는 그룹 이름입니다. 다른 이름을 쓰세요."), GROUP_NAME_CONFLICTS_USER(HttpStatus.BAD_REQUEST, "계정 이름과 같은 그룹 이름은 쓸 수 없습니다."), + GROUP_LIMIT_EXCEEDED(HttpStatus.BAD_REQUEST, "한 사람이 속할 수 있는 그룹은 5개까지예요. 속한 그룹을 줄인 뒤 다시 시도해 주세요."), + GROUP_LEAVE_NOT_MEMBER(HttpStatus.BAD_REQUEST, "속해 있지 않은 그룹이에요."), + GROUP_LEAVE_ALREADY_REQUESTED(HttpStatus.CONFLICT, "이 그룹의 탈퇴 신청이 이미 승인을 기다리고 있어요."), + GROUP_LEAVE_REQUEST_NOT_FOUND(HttpStatus.NOT_FOUND, "그룹 탈퇴 신청을 찾을 수 없습니다."), // AD 반영 실패는 DC 접속 장애 같은 일시적 원인이 대부분이라 다시 승인하면 되는 경우가 많다. // 이걸 형식 오류와 같은 코드로 묶으면 관리자가 신청이 잘못됐다고 판단하고 되돌린다. PRIMARY_GROUP_REMOVAL(HttpStatus.CONFLICT, "계정의 기본 그룹에서는 뺄 수 없습니다."), diff --git a/src/main/java/DGU_AI_LAB/admin_be/global/config/RuntimeDefaults.java b/src/main/java/DGU_AI_LAB/admin_be/global/config/RuntimeDefaults.java index 54568c4f..94a108f0 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/global/config/RuntimeDefaults.java +++ b/src/main/java/DGU_AI_LAB/admin_be/global/config/RuntimeDefaults.java @@ -23,7 +23,7 @@ public static Map values() { // 외부 호출 하나가 나머지를 전부 멈춘다. 예약 작업(@Scheduled)마다 스레드 하나씩 돌아가도록 개수에 // 맞춘다 — 모자라면 config-server가 멈춘 동안 폴러들이 스레드를 다 쥐어 그 장애를 알릴 Slack 워커까지 // 선다. 예약 작업을 늘리면 이 값도 늘린다(개수가 어긋나면 RuntimeDefaultsTest가 실패한다). 같은 신청을 동시에 만지는 경로는 행 잠금 + 상태 재확인을 거친다. - "spring.task.scheduling.pool.size", "19", + "spring.task.scheduling.pool.size", "20", // API 문서는 전체 경로와 요청 형식을 보여 준다. 운영에서는 끄고, 필요한 개발 환경만 설정 파일에서 켠다. "springdoc.api-docs.enabled", "false", "springdoc.swagger-ui.enabled", "false" diff --git a/src/main/java/DGU_AI_LAB/admin_be/global/validation/ExpectedGraduationDate.java b/src/main/java/DGU_AI_LAB/admin_be/global/validation/ExpectedGraduationDate.java new file mode 100644 index 00000000..e0a5c0df --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/global/validation/ExpectedGraduationDate.java @@ -0,0 +1,33 @@ +package DGU_AI_LAB.admin_be.global.validation; + +import jakarta.validation.Constraint; +import jakarta.validation.Payload; +import jakarta.validation.constraints.FutureOrPresent; +import jakarta.validation.constraints.NotNull; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * 졸업 예정일: 필수이고, 오늘부터 {@link #MAX_YEARS_AHEAD}년 안이어야 한다. 상한이 없으면 아주 먼 날짜를 넣어 + * 비활성화 규칙을 사실상 끌 수 있다. + */ +@Documented +@Constraint(validatedBy = ExpectedGraduationDateValidator.class) +@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.RECORD_COMPONENT}) +@Retention(RetentionPolicy.RUNTIME) +@NotNull +@FutureOrPresent +public @interface ExpectedGraduationDate { + + int MAX_YEARS_AHEAD = 6; + + String message() default "졸업 예정일은 오늘부터 6년 안의 날짜여야 합니다."; + + Class[] groups() default {}; + + Class[] payload() default {}; +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/global/validation/ExpectedGraduationDateValidator.java b/src/main/java/DGU_AI_LAB/admin_be/global/validation/ExpectedGraduationDateValidator.java new file mode 100644 index 00000000..94c5562b --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/global/validation/ExpectedGraduationDateValidator.java @@ -0,0 +1,15 @@ +package DGU_AI_LAB.admin_be.global.validation; + +import jakarta.validation.ConstraintValidator; +import jakarta.validation.ConstraintValidatorContext; + +import java.time.LocalDate; + +public class ExpectedGraduationDateValidator implements ConstraintValidator { + + @Override + public boolean isValid(LocalDate value, ConstraintValidatorContext context) { + // null·지난 날짜는 합성된 @NotNull·@FutureOrPresent가 거른다. + return value == null || !value.isAfter(LocalDate.now().plusYears(ExpectedGraduationDate.MAX_YEARS_AHEAD)); + } +} diff --git a/src/main/resources/db/migration/V19__requests_professor_approval.sql b/src/main/resources/db/migration/V19__requests_professor_approval.sql new file mode 100644 index 00000000..c9217792 --- /dev/null +++ b/src/main/resources/db/migration/V19__requests_professor_approval.sql @@ -0,0 +1,5 @@ +-- 관리자가 지도교수 승인을 확인하고 승인했다는 기록. 확인한 관리자(users.user_id)와 시각이다. +-- 이전에 승인된 신청과 관리자가 신청 없이 만드는 테스트 Pod 신청은 비어 있다. +ALTER TABLE `requests` + ADD COLUMN `professor_approval_confirmed_by` bigint NULL, + ADD COLUMN `professor_approval_confirmed_at` datetime(6) NULL; diff --git a/src/main/resources/db/migration/V20__users_expected_graduation_date.sql b/src/main/resources/db/migration/V20__users_expected_graduation_date.sql new file mode 100644 index 00000000..073c0aa3 --- /dev/null +++ b/src/main/resources/db/migration/V20__users_expected_graduation_date.sql @@ -0,0 +1,3 @@ +-- 졸업 예정일. 이 날짜 + 30일이 지나면 계정을 비활성화한다(마지막 컨테이너 종료 1년 규칙 대신). +-- 이전에 가입한 사용자는 비어 있고, 접속할 때 입력받는다. 비어 있는 동안은 1년 규칙이 그대로 적용된다. +ALTER TABLE `users` ADD COLUMN `expected_graduation_date` date NULL; diff --git a/src/main/resources/db/migration/V21__group_leave_requests.sql b/src/main/resources/db/migration/V21__group_leave_requests.sql new file mode 100644 index 00000000..794ebae1 --- /dev/null +++ b/src/main/resources/db/migration/V21__group_leave_requests.sql @@ -0,0 +1,18 @@ +-- 사용자가 신청하는 그룹 탈퇴. 관리자가 승인하면 기존 그룹 제거 작업(group_operations)으로 실제 소속을 뺀다. +-- 한 행이 신청 한 건이다. 같은 사용자·그룹의 PENDING 은 하나만 둔다(서비스가 확인). +CREATE TABLE `group_leave_requests` ( + `group_leave_request_id` bigint NOT NULL AUTO_INCREMENT, + `created_at` datetime(6) NOT NULL, + `updated_at` datetime(6) DEFAULT NULL, + `status` varchar(20) NOT NULL, + `user_id` bigint NOT NULL, + `group_id` bigint NOT NULL, + `decided_by` bigint DEFAULT NULL, + `decided_at` datetime(6) DEFAULT NULL, + PRIMARY KEY (`group_leave_request_id`), + KEY `idx_group_leave_requests_status` (`status`), + KEY `idx_group_leave_requests_user_group_status` (`user_id`, `group_id`, `status`), + CONSTRAINT `fk_group_leave_requests_user` FOREIGN KEY (`user_id`) REFERENCES `users` (`user_id`), + CONSTRAINT `fk_group_leave_requests_group` FOREIGN KEY (`group_id`) REFERENCES `groups` (`group_id`), + CONSTRAINT `fk_group_leave_requests_decided_by` FOREIGN KEY (`decided_by`) REFERENCES `users` (`user_id`) +) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci; diff --git a/src/main/resources/messages.properties b/src/main/resources/messages.properties index fb5782ab..aae85d57 100644 --- a/src/main/resources/messages.properties +++ b/src/main/resources/messages.properties @@ -201,23 +201,69 @@ notification.pod.cleanup.exhausted=[Pod 정리 직접 처리 필요]\n\ # {0}: \uB0A8\uC740 \uC77C\uC218 notification.user.delete-warning.subject=[DGU AI LAB] {0}일 뒤에 계정이 비활성화돼요 -# {0}: \uC0AC\uC6A9\uC790 \uC774\uB984, {1}: \uB0A8\uC740 \uC77C\uC218, {2}: \uC0AD\uC81C \uC608\uC815\uC77C +# {0}: \uC0AC\uC6A9\uC790 \uC774\uB984, {1}: \uB0A8\uC740 \uC77C\uC218, {2}: \uC0AD\uC81C \uC608\uC815\uC77C, {3}: 홈 삭제 안내 일수(home-retention.announced-days) notification.user.delete-warning.body=안녕하세요, {0}님.\n\ \n\ 마지막 컨테이너를 쓴 지(컨테이너를 쓴 적이 없다면 가입한 지) 1년이 다 되어 가요.\n\ 그래서 {1}일 뒤({2})에 계정이 비활성화돼요.\n\ 비활성화되면 로그인할 수 없고, 서버 계정도 정리돼요.\n\ + 홈 폴더의 파일은 마지막 컨테이너를 쓴 지 {3}일이 지나면 삭제되니, 필요한 파일은 미리 백업해 주세요.\n\ + 가입·사용·삭제 이력은 비활성화돼도 보존돼요.\n\ \n\ 계속 쓰고 싶다면 그 전에 웹사이트에서 컨테이너를 새로 신청해 주세요.\n\ 신청하면 비활성화가 자동으로 취소돼요. 로그인만 해서는 취소되지 않아요. +# [졸업 예정일 경과 계정 비활성화 예고] +# {0}: 남은 일수 +notification.user.graduation-warning.subject=[DGU AI LAB] {0}일 뒤에 계정이 비활성화돼요 + +# {0}: 사용자 이름, {1}: 남은 일수, {2}: 비활성화 예정일, {3}: 홈 삭제 안내 일수(home-retention.announced-days) +notification.user.graduation-warning.body=안녕하세요, {0}님.\n\ + \n\ + 입력해 주신 졸업 예정일이 지나서 {1}일 뒤({2})에 계정이 비활성화돼요.\n\ + 비활성화되면 로그인할 수 없고, 서버 계정도 정리돼요.\n\ + 홈 폴더의 파일은 마지막 컨테이너를 쓴 지 {3}일이 지나면 삭제되니, 필요한 파일은 미리 백업해 주세요.\n\ + 가입·사용·삭제 이력은 비활성화돼도 보존돼요.\n\ + \n\ + 졸업이 미뤄졌다면 그 전에 웹사이트에서 졸업 예정일을 바꿔 주세요.\n\ + 컨테이너를 새로 신청해서 쓰는 동안에는 비활성화되지 않아요. + +# [졸업 예정일 경과 계정 비활성화 완료] +# {0}: 사용자 이름, {1}: 홈 삭제 안내 일수(home-retention.announced-days) +notification.user.soft-delete.graduation.subject=[DGU AI LAB] 졸업 예정일이 지나 계정이 비활성화됐어요 + +notification.user.soft-delete.graduation.body=안녕하세요, {0}님.\n\ + \n\ + 입력해 주신 졸업 예정일이 지나서 계정을 비활성화했어요.\n\ + 이제 로그인할 수 없고, 서버 계정도 정리돼요.\n\ + 홈 폴더의 파일은 마지막 컨테이너를 쓴 지 {1}일이 지나면 삭제돼요. 이미 삭제됐을 수 있어요.\n\ + 가입·사용·삭제 이력은 보존돼요.\n\ + \n\ + 다시 쓰고 싶다면 문의 폼으로 알려 주세요.\n\ + - 문의 폼: https://forms.gle/nACaxj2UeJF56V2i7 + +# [홈 폴더 삭제 직전 안내] 안내한 삭제일의 7일 전·1일 전 +# {0}: 남은 일수 +notification.user.home-delete-reminder.subject=[DGU AI LAB] 홈 폴더가 {0}일 뒤에 삭제돼요 + +# {0}: 사용자 이름, {1}: 서버 계정 이름, {2}: 남은 일수, {3}: 삭제 안내일 +notification.user.home-delete-reminder.body=안녕하세요, {0}님.\n\ + \n\ + 홈 폴더(/home/{1})의 파일이 {2}일 뒤인 {3}부터 삭제돼요.\n\ + 필요한 파일은 그 전에 백업해 주세요.\n\ + \n\ + 계속 쓰고 싶다면 그 전에 웹사이트의 [GPU 신청]에서 새로 신청해 주세요.\n\ + 승인되면 기존 홈 폴더를 그대로 사용할 수 있어요. + # [Soft Delete \uC644\uB8CC] (\uBE44\uD65C\uC131\uD654) -# {0}: \uC0AC\uC6A9\uC790 \uC774\uB984 +# {0}: \uC0AC\uC6A9\uC790 \uC774\uB984, {1}: 홈 삭제 안내 일수(home-retention.announced-days) notification.user.soft-delete.subject=[DGU AI LAB] 오래 쓰지 않아서 계정이 비활성화됐어요 notification.user.soft-delete.body=안녕하세요, {0}님.\n\ \n\ 마지막 컨테이너를 쓴 지(컨테이너를 쓴 적이 없다면 가입한 지) 1년이 지나서 계정을 비활성화했어요.\n\ 이제 로그인할 수 없고, 서버 계정도 정리돼요.\n\ + 홈 폴더의 파일은 마지막 컨테이너를 쓴 지 {1}일이 지나면 삭제돼요. 이미 삭제됐을 수 있어요.\n\ + 가입·사용·삭제 이력은 보존돼요.\n\ \n\ 다시 쓰고 싶다면 문의 폼으로 알려 주세요.\n\ - 문의 폼: https://forms.gle/nACaxj2UeJF56V2i7 diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmServiceTest.java index 0ba3f8d8..d30fcca1 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmServiceTest.java @@ -238,6 +238,19 @@ void notifyUser_sendsMailDmAndReceipt() { assertThat(queued.get(1).getMessage()).isEqualTo("발송 기록"); } + @Test + @DisplayName("사용자 안내는 메일이 나갔을 때만 true를 돌려준다 — 호출부가 실패를 보고 다시 보낼 수 있게") + void notifyUser_returnsWhetherMailWasSent() { + when(messageUtils.get("notification.monitor.log", "홍길동", "hong@dgu.ac.kr", "제목")).thenReturn("발송 기록"); + + assertThat(alarmService.notifyUser("홍길동", "hong@dgu.ac.kr", "제목", "내용")).isTrue(); + + doThrow(new RuntimeException("SMTP 오류")).when(mailSender).send(any(SimpleMailMessage.class)); + when(messageUtils.get("notification.admin.mail-failed", "h***@dgu.ac.kr")).thenReturn("메일 실패"); + + assertThat(alarmService.notifyUser("홍길동", "hong@dgu.ac.kr", "제목", "내용")).isFalse(); + } + @Test @DisplayName("메일이 실패하면 오류 채널로 알리고 발송 기록은 남기지 않는다 — DM은 그대로 보낸다") void notifyUser_alertsInsteadOfReceipt_whenMailFails() { diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/groups/controller/GroupLeaveControllerTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/controller/GroupLeaveControllerTest.java new file mode 100644 index 00000000..de5cd287 --- /dev/null +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/controller/GroupLeaveControllerTest.java @@ -0,0 +1,119 @@ +package DGU_AI_LAB.admin_be.domain.groups.controller; + +import DGU_AI_LAB.admin_be.domain.groups.entity.Group; +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveRequest; +import DGU_AI_LAB.admin_be.domain.groups.service.GroupLeaveService; +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.global.auth.CustomUserDetails; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +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.core.context.SecurityContextHolder; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.web.method.annotation.AuthenticationPrincipalArgumentResolver; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; + +import java.util.List; + +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +/** 그룹 탈퇴 신청(사용자)·승인(관리자) 두 컨트롤러의 경로·상태 코드·로그인 사용자 전달을 확인한다. */ +@ExtendWith(MockitoExtension.class) +class GroupLeaveControllerTest { + + @Mock private GroupLeaveService groupLeaveService; + @InjectMocks private GroupLeaveController userController; + @InjectMocks private AdminGroupLeaveController adminController; + + private MockMvc userMvc; + private MockMvc adminMvc; + private GroupLeaveRequest leave; + + @BeforeEach + void setUp() { + User user = User.builder().email("a@dgu.ac.kr").password("p").name("홍길동") + .studentId("2021001234").phone("010-1111-2222").department("컴퓨터공학과").build(); + ReflectionTestUtils.setField(user, "userId", 7L); + Group group = Group.builder().groupName("vision-lab").ubuntuGid(2000L).build(); + ReflectionTestUtils.setField(group, "groupId", 12L); + leave = GroupLeaveRequest.pending(user, group); + ReflectionTestUtils.setField(leave, "groupLeaveRequestId", 3L); + + CustomUserDetails principal = new CustomUserDetails(user); + SecurityContextHolder.getContext().setAuthentication( + new UsernamePasswordAuthenticationToken(principal, null, principal.getAuthorities())); + userMvc = MockMvcBuilders.standaloneSetup(userController) + .setCustomArgumentResolvers(new AuthenticationPrincipalArgumentResolver()).build(); + adminMvc = MockMvcBuilders.standaloneSetup(adminController) + .setCustomArgumentResolvers(new AuthenticationPrincipalArgumentResolver()).build(); + } + + @AfterEach + void clear() { + SecurityContextHolder.clearContext(); + } + + @Test + @DisplayName("POST /api/groups/{id}/leave-requests: 201과 대기 상태 신청을 돌려주고 로그인 사용자로 신청한다") + void request() throws Exception { + when(groupLeaveService.request(7L, 12L)).thenReturn(leave); + + userMvc.perform(post("/api/groups/12/leave-requests")) + .andExpect(status().isCreated()) + .andExpect(jsonPath("$.data.leaveRequestId").value(3)) + .andExpect(jsonPath("$.data.status").value("PENDING")) + .andExpect(jsonPath("$.data.groupName").value("vision-lab")); + } + + @Test + @DisplayName("GET /api/groups/leave-requests/me: 내 신청 목록을 돌려준다") + void mine() throws Exception { + when(groupLeaveService.mine(7L)).thenReturn(List.of(leave)); + + userMvc.perform(get("/api/groups/leave-requests/me")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.data[0].userId").value(7)); + } + + @Test + @DisplayName("GET /api/admin/group-leave-requests: 승인 대기 목록을 돌려준다") + void pending() throws Exception { + when(groupLeaveService.pending()).thenReturn(List.of(leave)); + + adminMvc.perform(get("/api/admin/group-leave-requests")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.data[0].status").value("PENDING")); + } + + @Test + @DisplayName("POST .../approval: 202로 돌려주고 승인한 관리자 번호를 넘긴다") + void approve() throws Exception { + when(groupLeaveService.approve(3L, 7L)).thenReturn(leave); + + adminMvc.perform(post("/api/admin/group-leave-requests/3/approval")) + .andExpect(status().isAccepted()); + verify(groupLeaveService).approve(3L, 7L); + } + + @Test + @DisplayName("POST .../rejection: 200으로 돌려주고 거절한 관리자 번호를 넘긴다") + void reject() throws Exception { + when(groupLeaveService.reject(3L, 7L)).thenReturn(leave); + + adminMvc.perform(post("/api/admin/group-leave-requests/3/rejection")) + .andExpect(status().isOk()); + verify(groupLeaveService).reject(3L, 7L); + } +} diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveDecisionRaceIntegrationTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveDecisionRaceIntegrationTest.java new file mode 100644 index 00000000..d86e3ff9 --- /dev/null +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveDecisionRaceIntegrationTest.java @@ -0,0 +1,95 @@ +package DGU_AI_LAB.admin_be.domain.groups.service; + +import DGU_AI_LAB.admin_be.domain.groups.entity.Group; +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveRequest; +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveStatus; +import DGU_AI_LAB.admin_be.domain.groups.repository.GroupLeaveRequestRepository; +import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository; +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; +import DGU_AI_LAB.admin_be.error.ErrorCode; +import DGU_AI_LAB.admin_be.error.exception.BusinessException; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.context.annotation.Import; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.bean.override.mockito.MockitoBean; +import org.springframework.transaction.annotation.Propagation; +import org.springframework.transaction.annotation.Transactional; + +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.concurrent.atomic.AtomicReference; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +/** + * 같은 대기 신청에 승인과 거절이 동시에 들어와도 한쪽만 결정된다. 경합 시점을 mock 안에서 고정해 매번 같은 순서로 재현한다. 각 호출이 자기 트랜잭션을 쓰도록 테스트 트랜잭션을 + * 끄고, 픽스처는 커밋한 뒤 정리한다. + */ +@DataJpaTest +@ActiveProfiles("test") +@Import(GroupLeaveService.class) +@Transactional(propagation = Propagation.NOT_SUPPORTED) +class GroupLeaveDecisionRaceIntegrationTest { + + @Autowired private GroupLeaveService service; + @Autowired private GroupLeaveRequestRepository leaveRepository; + @Autowired private GroupRepository groupRepository; + @Autowired private UserRepository userRepository; + @MockitoBean private GroupOperationService groupOperationService; + + @Test + @DisplayName("승인이 제거 작업을 등록하는 동안 들어온 거절은 막혔다가 실패하고, 승인만 결정된다") + void rejectDuringApproveRegistrationIsBlockedAndFails() throws Exception { + Group group = groupRepository.save(Group.builder().groupName("race-lab").ubuntuGid(2900L).build()); + User member = userRepository.save(User.builder().email("race-member@dgu.ac.kr").password("p").name("이름") + .studentId("2099001111").phone("010-1111-2222").department("컴퓨터공학과").build()); + User admin = userRepository.save(User.builder().email("race-admin@dgu.ac.kr").password("p").name("관리") + .studentId("2099002222").phone("010-1111-3333").department("컴퓨터공학과").build()); + member.addGroupIfAbsent(group); + userRepository.save(member); + Long leaveId = service.request(member.getUserId(), group.getGroupId()).getGroupLeaveRequestId(); + + ExecutorService pool = Executors.newSingleThreadExecutor(); + AtomicReference> reject = new AtomicReference<>(); + // 승인이 제거 작업을 등록하는 순간에 거절을 끼워 넣는다. 잠금이 있으면 거절은 승인이 커밋할 때까지 막히고, + // 잠금이 없으면(확인→등록→기록이 따로 놀면) 거절이 먼저 결정해 버린다. H2 잠금 대기 한도(2초)보다 짧게 기다린다. + doAnswer(inv -> { + reject.set(pool.submit(() -> service.reject(leaveId, admin.getUserId()))); + try { + reject.get().get(500, TimeUnit.MILLISECONDS); + } catch (TimeoutException | ExecutionException blockedOrFailed) { + // 막혔으면 정상. 결과 판정은 아래에서 한다. + } + return null; + }).when(groupOperationService).requestRemove(member.getUserId(), group.getGroupId(), admin.getUserId()); + + try { + assertThat(service.approve(leaveId, admin.getUserId()).getStatus()).isEqualTo(GroupLeaveStatus.APPROVED); + + assertThatThrownBy(() -> reject.get().get(5, TimeUnit.SECONDS)) + .isInstanceOf(ExecutionException.class) + .cause().isInstanceOfSatisfying(BusinessException.class, + e -> assertThat(e.getErrorCode()).isEqualTo(ErrorCode.INVALID_REQUEST_STATUS)); + assertThat(leaveRepository.findById(leaveId).orElseThrow().getStatus()).isEqualTo(GroupLeaveStatus.APPROVED); + verify(groupOperationService, times(1)) + .requestRemove(member.getUserId(), group.getGroupId(), admin.getUserId()); + } finally { + pool.shutdownNow(); + leaveRepository.deleteAll(); + userRepository.deleteAll(); + groupRepository.deleteAll(); + } + } +} diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveServiceIntegrationTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveServiceIntegrationTest.java new file mode 100644 index 00000000..13fd40ec --- /dev/null +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveServiceIntegrationTest.java @@ -0,0 +1,126 @@ +package DGU_AI_LAB.admin_be.domain.groups.service; + +import DGU_AI_LAB.admin_be.domain.groups.dto.response.GroupLeaveResponseDTO; +import DGU_AI_LAB.admin_be.domain.groups.entity.Group; +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveRequest; +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveStatus; +import DGU_AI_LAB.admin_be.domain.groups.repository.GroupLeaveRequestRepository; +import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository; +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; +import DGU_AI_LAB.admin_be.error.ErrorCode; +import DGU_AI_LAB.admin_be.error.exception.BusinessException; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; +import org.springframework.context.annotation.Import; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.bean.override.mockito.MockitoBean; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; + +/** 탈퇴 신청 → 승인/거절 흐름을 실제 DB 표(H2)와 실제 저장소로 끝까지 따라간다. 제거 작업 등록만 대역을 쓴다. */ +@DataJpaTest +@ActiveProfiles("test") +@Import(GroupLeaveService.class) +class GroupLeaveServiceIntegrationTest { + + @Autowired private GroupLeaveService service; + @Autowired private GroupLeaveRequestRepository leaveRepository; + @Autowired private GroupRepository groupRepository; + @Autowired private UserRepository userRepository; + @Autowired private TestEntityManager em; + @MockitoBean private GroupOperationService groupOperationService; + + private User member; + private User admin; + private Group group; + + @BeforeEach + void setUp() { + group = groupRepository.save(Group.builder().groupName("vision-lab").ubuntuGid(2000L).build()); + member = userRepository.save(user("member@dgu.ac.kr", "2021001111")); + admin = userRepository.save(user("admin@dgu.ac.kr", "2021002222")); + member.addGroupIfAbsent(group); + em.flush(); + em.clear(); + } + + private User user(String email, String studentId) { + return User.builder().email(email).password("p").name("이름").studentId(studentId) + .phone("010-1111-2222").department("컴퓨터공학과").build(); + } + + @Test + @DisplayName("신청 → 대기 목록 → 승인: 상태가 APPROVED로 저장되고 제거 작업이 등록된다") + void requestThenApprove() { + GroupLeaveRequest requested = service.request(member.getUserId(), group.getGroupId()); + em.flush(); + em.clear(); + + assertThat(service.pending()).extracting(GroupLeaveRequest::getGroupLeaveRequestId) + .containsExactly(requested.getGroupLeaveRequestId()); + assertThat(service.mine(member.getUserId())).hasSize(1); + + GroupLeaveRequest approved = service.approve(requested.getGroupLeaveRequestId(), admin.getUserId()); + em.flush(); + em.clear(); + // 컨트롤러는 트랜잭션 밖에서 응답을 만든다 — 지연 로딩 프록시가 남아 있으면 여기서 터진다. + assertThat(GroupLeaveResponseDTO.fromEntity(approved).groupName()).isEqualTo("vision-lab"); + + GroupLeaveRequest saved = leaveRepository.findById(requested.getGroupLeaveRequestId()).orElseThrow(); + assertThat(saved.getStatus()).isEqualTo(GroupLeaveStatus.APPROVED); + assertThat(saved.getDecidedAt()).isNotNull(); + assertThat(service.pending()).isEmpty(); + verify(groupOperationService).requestRemove(member.getUserId(), group.getGroupId(), admin.getUserId()); + } + + @Test + @DisplayName("거절하면 REJECTED로 저장되고 제거 작업은 등록되지 않는다") + void reject() { + GroupLeaveRequest requested = service.request(member.getUserId(), group.getGroupId()); + GroupLeaveRequest rejected = service.reject(requested.getGroupLeaveRequestId(), admin.getUserId()); + em.flush(); + em.clear(); + assertThat(GroupLeaveResponseDTO.fromEntity(rejected).userName()).isEqualTo("이름"); + + assertThat(leaveRepository.findById(requested.getGroupLeaveRequestId()).orElseThrow().getStatus()) + .isEqualTo(GroupLeaveStatus.REJECTED); + verifyNoInteractions(groupOperationService); + } + + @Test + @DisplayName("같은 그룹을 대기 중에 다시 신청하거나, 이미 결정된 신청을 다시 결정하면 거부된다") + void duplicateAndDecidedAreRejected() { + GroupLeaveRequest requested = service.request(member.getUserId(), group.getGroupId()); + em.flush(); + + assertThatThrownBy(() -> service.request(member.getUserId(), group.getGroupId())) + .isInstanceOf(BusinessException.class) + .extracting(e -> ((BusinessException) e).getErrorCode()).isEqualTo(ErrorCode.GROUP_LEAVE_ALREADY_REQUESTED); + + service.reject(requested.getGroupLeaveRequestId(), admin.getUserId()); + assertThatThrownBy(() -> service.approve(requested.getGroupLeaveRequestId(), admin.getUserId())) + .isInstanceOf(BusinessException.class) + .extracting(e -> ((BusinessException) e).getErrorCode()).isEqualTo(ErrorCode.INVALID_REQUEST_STATUS); + } + + @Test + @DisplayName("속하지 않은 그룹은 신청할 수 없다") + void nonMemberRejected() { + Group other = groupRepository.save(Group.builder().groupName("other").ubuntuGid(2001L).build()); + + assertThatThrownBy(() -> service.request(member.getUserId(), other.getGroupId())) + .isInstanceOf(BusinessException.class) + .extracting(e -> ((BusinessException) e).getErrorCode()).isEqualTo(ErrorCode.GROUP_LEAVE_NOT_MEMBER); + assertThat(service.mine(member.getUserId())).isEqualTo(List.of()); + } +} diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveServiceTest.java new file mode 100644 index 00000000..9bb9aa99 --- /dev/null +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupLeaveServiceTest.java @@ -0,0 +1,172 @@ +package DGU_AI_LAB.admin_be.domain.groups.service; + +import DGU_AI_LAB.admin_be.domain.groups.entity.Group; +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveRequest; +import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveStatus; +import DGU_AI_LAB.admin_be.domain.groups.repository.GroupLeaveRequestRepository; +import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository; +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; +import DGU_AI_LAB.admin_be.error.ErrorCode; +import DGU_AI_LAB.admin_be.error.exception.BusinessException; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; +import org.springframework.test.util.ReflectionTestUtils; + +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.LENIENT) +@DisplayName("GroupLeaveService") +class GroupLeaveServiceTest { + + @Mock private GroupLeaveRequestRepository leaveRepository; + @Mock private GroupRepository groupRepository; + @Mock private UserRepository userRepository; + @Mock private GroupOperationService groupOperationService; + + private GroupLeaveService service; + private User user; + private Group group; + + @BeforeEach + void setUp() { + service = new GroupLeaveService(leaveRepository, groupRepository, userRepository, groupOperationService); + user = User.builder().email("a@dgu.ac.kr").password("pw").name("홍").studentId("1") + .phone("010").department("과").build(); + ReflectionTestUtils.setField(user, "userId", 7L); + group = Group.builder().groupName("team").build(); + ReflectionTestUtils.setField(group, "groupId", 3L); + user.addGroupIfAbsent(group); + when(userRepository.findByIdForUpdate(7L)).thenReturn(Optional.of(user)); + when(groupRepository.findById(3L)).thenReturn(Optional.of(group)); + when(leaveRepository.save(any(GroupLeaveRequest.class))).thenAnswer(i -> i.getArgument(0)); + } + + private static ErrorCode codeOf(Throwable e) { + return ((BusinessException) e).getErrorCode(); + } + + @Test + @DisplayName("속한 그룹의 탈퇴를 신청하면 승인 대기로 저장한다") + void requestsLeave() { + GroupLeaveRequest saved = service.request(7L, 3L); + + assertThat(saved.getStatus()).isEqualTo(GroupLeaveStatus.PENDING); + assertThat(saved.getUser()).isSameAs(user); + assertThat(saved.getGroup()).isSameAs(group); + } + + @Test + @DisplayName("속하지 않은 그룹이면 GROUP_LEAVE_NOT_MEMBER") + void rejectsNonMember() { + user.removeGroup(3L); + + assertThatThrownBy(() -> service.request(7L, 3L)) + .isInstanceOf(BusinessException.class) + .satisfies(e -> assertThat(codeOf(e)).isEqualTo(ErrorCode.GROUP_LEAVE_NOT_MEMBER)); + verify(leaveRepository, never()).save(any()); + } + + @Test + @DisplayName("기본 그룹(계정 이름과 같은 그룹)은 접수에서 PRIMARY_GROUP_REMOVAL로 거절한다") + void rejectsPrimaryGroup() { + ReflectionTestUtils.setField(user, "ubuntuUsername", "team"); + + assertThatThrownBy(() -> service.request(7L, 3L)) + .isInstanceOf(BusinessException.class) + .satisfies(e -> assertThat(codeOf(e)).isEqualTo(ErrorCode.PRIMARY_GROUP_REMOVAL)); + verify(leaveRepository, never()).save(any()); + } + + @Test + @DisplayName("제거 작업 등록이 실패하면 신청은 대기로 남는다") + void approveFailureKeepsPending() { + GroupLeaveRequest pending = GroupLeaveRequest.pending(user, group); + when(leaveRepository.findByIdForUpdate(5L)).thenReturn(Optional.of(pending)); + when(groupOperationService.requestRemove(7L, 3L, 9L)).thenThrow(new BusinessException(ErrorCode.GROUP_CHANGE_FAILED)); + + assertThatThrownBy(() -> service.approve(5L, 9L)).isInstanceOf(BusinessException.class); + + assertThat(pending.getStatus()).isEqualTo(GroupLeaveStatus.PENDING); + } + + @Test + @DisplayName("같은 그룹의 대기 중인 신청이 있으면 GROUP_LEAVE_ALREADY_REQUESTED") + void rejectsDuplicatePending() { + when(leaveRepository.existsByUser_UserIdAndGroup_GroupIdAndStatus(7L, 3L, GroupLeaveStatus.PENDING)) + .thenReturn(true); + + assertThatThrownBy(() -> service.request(7L, 3L)) + .isInstanceOf(BusinessException.class) + .satisfies(e -> assertThat(codeOf(e)).isEqualTo(ErrorCode.GROUP_LEAVE_ALREADY_REQUESTED)); + } + + @Test + @DisplayName("승인하면 기존 그룹 제거 작업을 관리자 이름으로 등록하고 승인됨으로 바꾼다") + void approveRegistersRemoval() { + GroupLeaveRequest pending = GroupLeaveRequest.pending(user, group); + when(leaveRepository.findByIdForUpdate(5L)).thenReturn(Optional.of(pending)); + User admin = User.builder().email("admin@dgu.ac.kr").password("pw").name("관").studentId("2") + .phone("010").department("과").build(); + when(userRepository.getReferenceById(9L)).thenReturn(admin); + + service.approve(5L, 9L); + + assertThat(pending.getStatus()).isEqualTo(GroupLeaveStatus.APPROVED); + assertThat(pending.getDecidedBy()).isSameAs(admin); + verify(groupOperationService).requestRemove(7L, 3L, 9L); + } + + @Test + @DisplayName("승인은 신청 행을 한 번만 잠가 확인·등록·승인 기록을 한 트랜잭션 안에서 한다") + void approveLocksRequestOnce() { + GroupLeaveRequest pending = GroupLeaveRequest.pending(user, group); + when(leaveRepository.findByIdForUpdate(5L)).thenReturn(Optional.of(pending)); + + service.approve(5L, 9L); + + verify(leaveRepository, times(1)).findByIdForUpdate(5L); + verify(groupOperationService).requestRemove(7L, 3L, 9L); + } + + @Test + @DisplayName("이미 처리된 신청은 승인할 수 없다") + void approveRejectsAlreadyDecided() { + GroupLeaveRequest done = GroupLeaveRequest.pending(user, group); + ReflectionTestUtils.setField(done, "status", GroupLeaveStatus.REJECTED); + when(leaveRepository.findByIdForUpdate(5L)).thenReturn(Optional.of(done)); + + assertThatThrownBy(() -> service.approve(5L, 9L)) + .isInstanceOf(BusinessException.class) + .satisfies(e -> assertThat(codeOf(e)).isEqualTo(ErrorCode.INVALID_REQUEST_STATUS)); + verify(groupOperationService, never()).requestRemove(any(), any(), any()); + } + + @Test + @DisplayName("거절하면 거절됨으로 바꾸고 제거 작업은 등록하지 않는다") + void rejectDoesNotRemove() { + GroupLeaveRequest pending = GroupLeaveRequest.pending(user, group); + when(leaveRepository.findByIdForUpdate(5L)).thenReturn(Optional.of(pending)); + when(userRepository.getReferenceById(9L)).thenReturn(user); + + service.reject(5L, 9L); + + assertThat(pending.getStatus()).isEqualTo(GroupLeaveStatus.REJECTED); + verify(groupOperationService, never()).requestRemove(any(), any(), any()); + } +} diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupMembershipPolicyTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupMembershipPolicyTest.java new file mode 100644 index 00000000..0dd00ba0 --- /dev/null +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupMembershipPolicyTest.java @@ -0,0 +1,63 @@ +package DGU_AI_LAB.admin_be.domain.groups.service; + +import DGU_AI_LAB.admin_be.domain.groups.entity.Group; +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.error.ErrorCode; +import DGU_AI_LAB.admin_be.error.exception.BusinessException; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.test.util.ReflectionTestUtils; + +import java.util.List; +import java.util.stream.IntStream; + +import static org.assertj.core.api.Assertions.assertThatCode; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +@DisplayName("GroupMembershipPolicy") +class GroupMembershipPolicyTest { + + private final GroupMembershipPolicy policy = new GroupMembershipPolicy(); + + private static Group group(long id) { + Group group = Group.builder().groupName("g" + id).build(); + ReflectionTestUtils.setField(group, "groupId", id); + return group; + } + + private static User userInGroups(int count) { + User user = User.builder().email("a@dgu.ac.kr").password("pw").name("홍").studentId("1") + .phone("010").department("과").build(); + IntStream.rangeClosed(1, count).forEach(i -> user.addGroupIfAbsent(group(i))); + return user; + } + + @Test + @DisplayName("지금 속한 그룹과 새로 넣을 그룹을 합쳐 5개면 허용한다") + void allowsUpToFive() { + assertThatCode(() -> policy.requireRoomFor(userInGroups(3), List.of(group(10), group(11)))) + .doesNotThrowAnyException(); + } + + @Test + @DisplayName("합쳐서 5개를 넘으면 GROUP_LIMIT_EXCEEDED") + void rejectsOverFive() { + assertThatThrownBy(() -> policy.requireRoomFor(userInGroups(4), List.of(group(10), group(11)))) + .isInstanceOf(BusinessException.class) + .extracting(e -> ((BusinessException) e).getErrorCode()) + .isEqualTo(ErrorCode.GROUP_LIMIT_EXCEEDED); + } + + @Test + @DisplayName("이미 속한 그룹은 새로 세지 않는다") + void doesNotCountGroupsAlreadyJoined() { + assertThatCode(() -> policy.requireRoomFor(userInGroups(5), List.of(group(1), group(2)))) + .doesNotThrowAnyException(); + } + + @Test + @DisplayName("넣을 그룹이 없으면 이미 5개여도 통과한다") + void emptyJoinIsAllowed() { + assertThatCode(() -> policy.requireRoomFor(userInGroups(5), List.of())).doesNotThrowAnyException(); + } +} diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupOperationServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupOperationServiceTest.java index 892cdb27..c4218c75 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupOperationServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/groups/service/GroupOperationServiceTest.java @@ -46,6 +46,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.argThat; import static org.mockito.ArgumentMatchers.anyList; import static org.mockito.ArgumentMatchers.anyString; @@ -76,6 +77,7 @@ class GroupOperationServiceTest { @Mock private UserGuideMailer userGuideMailer; @Mock private PlatformTransactionManager transactionManager; @Mock private TransactionStatus transactionStatus; + @Mock private GroupMembershipPolicy groupMembershipPolicy; private GroupOperationService service; private User user; @@ -87,7 +89,7 @@ void setUp() { when(transactionManager.getTransaction(any())).thenReturn(transactionStatus); service = new GroupOperationService(operationRepository, groupRepository, userRepository, requestRepository, changeRequestRepository, jobClient, alarmService, requestChannelNotifier, userGuideMailer, new ObjectMapper(), - transactionManager); + transactionManager, groupMembershipPolicy); user = user(USER_ID, "alice"); admin = user(ADMIN_ID, "root-admin"); @@ -219,6 +221,19 @@ void approvalRegistersJobAndMarksProcessing() { assertThat(user.getUserGroups()).isEmpty(); } + @Test + @DisplayName("승인 때 그룹 한도를 넘으면 등록하지 않는다 — 접수 뒤 다른 요청이 먼저 승인된 경우") + void limitIsRecheckedAtApproval() { + doThrow(new BusinessException(ErrorCode.GROUP_LIMIT_EXCEEDED)) + .when(groupMembershipPolicy).requireRoomFor(eq(user), any()); + + assertThatThrownBy(() -> service.startAdd(changeRequest, originalRequest, admin, null)) + .isInstanceOf(BusinessException.class) + .extracting("errorCode").isEqualTo(ErrorCode.GROUP_LIMIT_EXCEEDED); + verifyNoInteractions(jobClient); + assertThat(changeRequest.getStatus()).isEqualTo(Status.PENDING); + } + @Test @DisplayName("없는 그룹이 섞여 있으면 등록하지 않는다") void unknownGroupIsNotRegistered() { diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/controller/AdminRequestControllerTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/controller/AdminRequestControllerTest.java index a16cf444..0e6f5fa3 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/controller/AdminRequestControllerTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/controller/AdminRequestControllerTest.java @@ -1,5 +1,12 @@ package DGU_AI_LAB.admin_be.domain.requests.controller; +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.global.auth.CustomUserDetails; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.security.web.method.annotation.AuthenticationPrincipalArgumentResolver; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; import DGU_AI_LAB.admin_be.domain.requests.job.JobHistoryService; import DGU_AI_LAB.admin_be.domain.requests.service.AdminRequestCommandService; import DGU_AI_LAB.admin_be.domain.requests.service.AdminRequestQueryService; @@ -44,6 +51,7 @@ class AdminRequestControllerTest extends WebMvcTestSupport { @Autowired private MockMvc mockMvc; + @Autowired private AdminRequestController adminRequestController; @MockitoBean private AdminRequestCommandService adminRequestCommandService; @MockitoBean private AdminRequestQueryService adminRequestQueryService; @MockitoBean private PodMigrationService podMigrationService; @@ -111,17 +119,60 @@ void getOne() throws Exception { verify(adminRequestQueryService).getRequest(12L); } + private static final String APPROVAL_BODY = + "{\"imageId\": 3, \"resourceGroupId\": 2, \"adminComment\": \"ok\", \"professorApprovalConfirmed\": true}"; + + private MockMvc approvalMvc() { + return MockMvcBuilders.standaloneSetup(adminRequestController) + .setCustomArgumentResolvers(new AuthenticationPrincipalArgumentResolver()).build(); + } + @Test - @DisplayName("POST /{id}/approval: 경로의 신청 번호로 생성 작업을 등록하고 202를 반환한다") + @DisplayName("POST /{id}/approval: 경로의 신청 번호로 생성 작업을 등록하고 승인한 관리자를 기록해 202를 반환한다") void approvalIsAccepted() throws Exception { - mockMvc.perform(post("/api/admin/requests/12/approval") - .contentType(MediaType.APPLICATION_JSON) - .content("{\"imageId\": 3, \"resourceGroupId\": 2, \"adminComment\": \"ok\"}")) - .andExpect(status().isAccepted()) - .andExpect(jsonPath("$.status").value(202)); + User admin = User.builder().email("a@dgu.ac.kr").password("p").name("관리자") + .studentId("1").phone("010").department("과").build(); + ReflectionTestUtils.setField(admin, "userId", 77L); + CustomUserDetails principal = new CustomUserDetails(admin); + SecurityContextHolder.getContext().setAuthentication( + new UsernamePasswordAuthenticationToken(principal, null, principal.getAuthorities())); + try { + approvalMvc().perform(post("/api/admin/requests/12/approval") + .contentType(MediaType.APPLICATION_JSON).content(APPROVAL_BODY)) + .andExpect(status().isAccepted()) + .andExpect(jsonPath("$.status").value(202)); + } finally { + SecurityContextHolder.clearContext(); + } verify(adminRequestCommandService).approveRequest(argThat(dto -> - dto.requestId() == 12L && dto.imageId() == 3L && dto.resourceGroupId() == 2)); + dto.requestId() == 12L && dto.imageId() == 3L && dto.resourceGroupId() == 2 + && Long.valueOf(77L).equals(dto.professorApprovedByAdminId()))); + } + + @Test + @DisplayName("POST /{id}/approval: 로그인한 관리자를 알 수 없으면 승인하지 않는다") + void approvalWithoutPrincipalIsRejected() throws Exception { + SecurityContextHolder.clearContext(); + + mockMvc.perform(post("/api/admin/requests/12/approval") + .contentType(MediaType.APPLICATION_JSON).content(APPROVAL_BODY)) + .andExpect(status().isUnauthorized()); + verifyNoInteractions(adminRequestCommandService); + } + + @Test + @DisplayName("POST /{id}/approval: 지도교수 승인 확인이 없거나 false면 400이고 승인하지 않는다") + void approvalRequiresProfessorConfirmation() throws Exception { + for (String body : new String[]{ + "{\"imageId\": 3, \"resourceGroupId\": 2}", + "{\"imageId\": 3, \"resourceGroupId\": 2, \"professorApprovalConfirmed\": false}"}) { + mockMvc.perform(post("/api/admin/requests/12/approval") + .contentType(MediaType.APPLICATION_JSON) + .content(body)) + .andExpect(status().isBadRequest()); + } + verifyNoInteractions(adminRequestCommandService); } @Test diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/RequestDtoValidationTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/RequestDtoValidationTest.java index a44a764e..4ae8f841 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/RequestDtoValidationTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/RequestDtoValidationTest.java @@ -126,6 +126,19 @@ void formAnswers_overTotalLength_isRejectedOnSave() { } } + @Nested + @DisplayName("지도교수 승인 확인") + class ProfessorApproval { + + @Test + @DisplayName("승인 본문은 지도교수 승인 확인이 true일 때만 통과한다") + void approvalBodyRequiresConfirmation() { + assertThat(violatedPaths(new ApprovalRequestDTO(1L, 1, null, true))).isEmpty(); + assertThat(violatedPaths(new ApprovalRequestDTO(1L, 1, null, false))).contains("professorApprovalConfirmed"); + assertThat(violatedPaths(new ApprovalRequestDTO(1L, 1, null, null))).contains("professorApprovalConfirmed"); + } + } + @Nested @DisplayName("관리자 코멘트 길이 (DB 컬럼 초과 시 500 방지)") class AdminComments { diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/entity/RequestTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/entity/RequestTest.java index 7cbe316c..a35bef25 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/entity/RequestTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/entity/RequestTest.java @@ -42,6 +42,71 @@ private void fulfill() { request.completeApproval(); } + @Nested + @DisplayName("교수 승인 확인 기록의 정리") + class ProfessorApprovalRecordCleanup { + + @Test + @DisplayName("승인이 실패해 대기로 돌아가면 확인 기록을 지워, 다음 관리자가 승인할 때 그 관리자가 남는다") + void revertToPendingClearsRecord() { + request.markAsProcessing(); + request.confirmProfessorApproval(5L); + + request.revertToPending(); + assertThat(request.getProfessorApprovalConfirmedBy()).isNull(); + assertThat(request.getProfessorApprovalConfirmedAt()).isNull(); + + request.markAsProcessing(); + request.confirmProfessorApproval(7L); + assertThat(request.getProfessorApprovalConfirmedBy()).isEqualTo(7L); + } + + @Test + @DisplayName("거절해도 누가 교수 승인을 확인했는지는 감사 기록으로 남긴다") + void rejectKeepsRecord() { + request.markAsProcessing(); + request.confirmProfessorApproval(5L); + + request.reject("사유"); + + assertThat(request.getProfessorApprovalConfirmedBy()).isEqualTo(5L); + assertThat(request.getProfessorApprovalConfirmedAt()).isNotNull(); + } + } + + @Nested + @DisplayName("confirmProfessorApproval") + class ConfirmProfessorApproval { + + @Test + @DisplayName("지도교수 승인을 확인한 관리자와 시각이 남는다") + void recordsAdminAndTime() { + request.confirmProfessorApproval(9L); + + assertThat(request.getProfessorApprovalConfirmedBy()).isEqualTo(9L); + assertThat(request.getProfessorApprovalConfirmedAt()).isNotNull(); + } + + @Test + @DisplayName("다시 승인해도 처음 확인한 관리자와 시각을 덮어쓰지 않는다") + void doesNotOverwriteFirstConfirmation() { + request.confirmProfessorApproval(9L); + var firstAt = request.getProfessorApprovalConfirmedAt(); + + request.confirmProfessorApproval(10L); + + assertThat(request.getProfessorApprovalConfirmedBy()).isEqualTo(9L); + assertThat(request.getProfessorApprovalConfirmedAt()).isEqualTo(firstAt); + } + + @Test + @DisplayName("확인하지 않은 신청은 비어 있다") + void emptyByDefault() { + assertThat(request.getProfessorApprovalConfirmedBy()).isNull(); + assertThat(request.getProfessorApprovalConfirmedAt()).isNull(); + } + } + @Nested @DisplayName("completeApproval") class CompleteApproval { diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceApprovalContractTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceApprovalContractTest.java index d724ee80..026ebc25 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceApprovalContractTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceApprovalContractTest.java @@ -152,6 +152,28 @@ void newAccountApprovalLocksAndMarksProcessingBeforeRegistering() { } + @Test + @DisplayName("관리자가 지도교수 승인을 확인하고 승인하면 그 관리자가 신청에 기록된다") + void recordsProfessorApprovalAdmin() { + Long requestId = 310L; + Request request = approvableRequest(requestId); + + service.approveRequest(new ApproveRequestDTO(requestId, 1L, 1, null, 9L)); + + verify(request).confirmProfessorApproval(9L); + } + + @Test + @DisplayName("승인자 없이 승인하는 경로(테스트 Pod 자동 승인)는 지도교수 승인을 기록하지 않는다") + void doesNotRecordProfessorApprovalWithoutAdmin() { + Long requestId = 311L; + Request request = approvableRequest(requestId); + + service.approveRequest(new ApproveRequestDTO(requestId, 1L, 1, null)); + + verify(request, never()).confirmProfessorApproval(any()); + } + @Test @DisplayName("계정이 회수된 사람은 영구히 귀속된 자기 UID를 expected_uid로 보내 같은 번호·같은 홈으로 되살린다") void sendsOwnUidWhenAccountReleased() { diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/RequestCommandServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/RequestCommandServiceTest.java index 6a3071a5..08eea3b4 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/RequestCommandServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/RequestCommandServiceTest.java @@ -6,6 +6,7 @@ import DGU_AI_LAB.admin_be.domain.containerImage.repository.ContainerImageRepository; import DGU_AI_LAB.admin_be.domain.groups.entity.Group; import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository; +import DGU_AI_LAB.admin_be.domain.groups.service.GroupMembershipPolicy; import DGU_AI_LAB.admin_be.domain.groups.service.PendingGroupService; import DGU_AI_LAB.admin_be.domain.portRequests.service.PortRequestService; import DGU_AI_LAB.admin_be.domain.requests.dto.request.SingleChangeRequestDTO; @@ -33,6 +34,7 @@ import jakarta.persistence.EntityManager; import org.mockito.ArgumentCaptor; import org.mockito.InjectMocks; +import org.mockito.Spy; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; @@ -67,8 +69,8 @@ class RequestCommandServiceTest { @InjectMocks private RequestCommandService requestCommandService; - @Mock - private ObjectMapper objectMapper; + @Spy + private ObjectMapper objectMapper = new ObjectMapper(); @Mock private RequestRepository requestRepository; @@ -106,6 +108,9 @@ class RequestCommandServiceTest { @Mock private PendingGroupService pendingGroupService; + @Mock + private GroupMembershipPolicy groupMembershipPolicy; + /** 가입 시 우분투 계정명이 정해진 사용자 — 신청은 이 값을 그대로 복사해 쓴다. */ /** 가입(또는 로그인) 때 웹 비밀번호로 SSH 비밀번호 해시가 채워진 사용자. */ private static User userWithUbuntuUsername(String ubuntuUsername) { @@ -372,6 +377,30 @@ void createSingleChangeRequest_throwsConflict_whenSameTypeAlreadyPending() { verify(requestChannelNotifier, never()).sendChangeRequestNotification(any()); } + @Test + @DisplayName("그룹 추가 변경 요청이 한 사람 한도(5개)를 넘으면 받지 않는다") + void createSingleChangeRequest_overGroupLimit_isRejected() { + User owner = mock(User.class); + when(owner.getUserId()).thenReturn(1L); + when(owner.getUserGroups()).thenReturn(Set.of()); + Request request = mock(Request.class); + when(request.getUser()).thenReturn(owner); + when(request.getStatus()).thenReturn(Status.FULFILLED); + when(requestRepository.findByIdForUpdate(14L)).thenReturn(Optional.of(request)); + Group wanted = Group.builder().groupName("ailab").ubuntuGid(1005L).build(); + when(groupRepository.findAllByUbuntuGidIn(Set.of(1005L))).thenReturn(List.of(wanted)); + doThrow(new BusinessException(ErrorCode.GROUP_LIMIT_EXCEEDED)) + .when(groupMembershipPolicy).requireRoomFor(eq(owner), any()); + + SingleChangeRequestDTO dto = new SingleChangeRequestDTO(14L, ChangeType.GROUP, "[1005]", REASON); + + assertThatThrownBy(() -> requestCommandService.createSingleChangeRequest(1L, dto)) + .isInstanceOf(BusinessException.class) + .extracting(e -> ((BusinessException) e).getErrorCode()) + .isEqualTo(ErrorCode.GROUP_LIMIT_EXCEEDED); + verify(changeRequestRepository, never()).save(any()); + } + @Test @DisplayName("변경 요청을 받으면 알림 기록 채널에 접수 사실을 남긴다") void createSingleChangeRequest_recordsReceipt() { @@ -585,6 +614,26 @@ void createRequest_byGroupIds_unknownGroup_isRejected() { verifyNoInteractions(requestCreateThrottle); } + @Test + @DisplayName("고른 그룹이 한 사람 한도(5개)를 넘으면 저장하지 않고 하루 한도도 세지 않는다") + void createRequest_overGroupLimit_isRejected() { + User user = userWithUbuntuUsername("honggildong"); + SaveRequestRequestDTO dto = stubbedCreate(user); + Group chosen = Group.builder().groupName("ailab").ubuntuGid(2001L).build(); + ReflectionTestUtils.setField(chosen, "groupId", 4L); + when(dto.groupIds()).thenReturn(Set.of(4L)); + when(groupRepository.findAllByIdForUpdate(Set.of(4L))).thenReturn(List.of(chosen)); + doThrow(new BusinessException(ErrorCode.GROUP_LIMIT_EXCEEDED)) + .when(groupMembershipPolicy).requireRoomFor(eq(user), any()); + + assertThatThrownBy(() -> requestCommandService.createRequest(1L, dto)) + .isInstanceOf(BusinessException.class) + .extracting(e -> ((BusinessException) e).getErrorCode()) + .isEqualTo(ErrorCode.GROUP_LIMIT_EXCEEDED); + verify(requestRepository, never()).saveAndFlush(any()); + verifyNoInteractions(requestCreateThrottle); + } + @Test @DisplayName("groupIds와 ubuntuGids를 함께 보내면 어느 쪽을 믿을지 알 수 없어 400으로 거절한다") void createRequest_bothGroupFields_isRejected() { diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderSchedulerTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderSchedulerTest.java new file mode 100644 index 00000000..b4134830 --- /dev/null +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderSchedulerTest.java @@ -0,0 +1,190 @@ +package DGU_AI_LAB.admin_be.domain.scheduler; + +import DGU_AI_LAB.admin_be.domain.alarm.service.AlarmService; +import DGU_AI_LAB.admin_be.domain.home.service.HomeRetentionPolicy; +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; +import DGU_AI_LAB.admin_be.global.util.MessageUtils; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; +import org.springframework.data.redis.core.RedisTemplate; +import org.springframework.data.redis.core.ValueOperations; + +import java.time.Duration; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.util.List; +import java.util.Optional; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.LENIENT) +@DisplayName("HomeDeletionReminderScheduler") +class HomeDeletionReminderSchedulerTest { + + // 안내 삭제일은 마지막 컨테이너가 끝난 날 + 30일이다(HomeRetentionPolicy 기본값). + private static final LocalDate TODAY = LocalDate.of(2026, 11, 10); + // 10/18에 끝난 계정의 안내 삭제일은 11/17이다. + private static final LocalDate ENDED_10_18 = LocalDate.of(2026, 10, 18); + + @Mock private UserRepository userRepository; + @Mock private AlarmService alarmService; + @Mock private MessageUtils messageUtils; + @Mock private RedisTemplate redisTemplate; + @Mock private ValueOperations valueOps; + + private HomeDeletionReminderScheduler scheduler; + + @BeforeEach + void setUp() { + when(redisTemplate.opsForValue()).thenReturn(valueOps); + when(valueOps.setIfAbsent(anyString(), any(), any(Duration.class))).thenReturn(true); + when(messageUtils.get(anyString(), any(Object[].class))).thenAnswer(i -> i.getArgument(0)); + when(alarmService.notifyUser(anyString(), anyString(), anyString(), anyString())).thenReturn(true); + when(userRepository.findHomeReminderCandidates(any(), any(), any())).thenReturn(List.of()); + scheduler = new HomeDeletionReminderScheduler( + userRepository, new HomeRetentionPolicy(), alarmService, messageUtils, redisTemplate); + } + + private User user(Long id, String name, String email, String username, LocalDate endedOn) { + User user = mock(User.class); + when(user.getUserId()).thenReturn(id); + when(user.getName()).thenReturn(name); + when(user.getEmail()).thenReturn(email); + when(user.getUbuntuUsername()).thenReturn(username); + when(user.lastContainerEndedAt()).thenReturn(Optional.of(endedOn.atStartOfDay())); + return user; + } + + private void candidates(User... users) { + when(userRepository.findHomeReminderCandidates(any(), any(), any())).thenReturn(List.of(users)); + } + + @Test + @DisplayName("삭제일이 오늘 뒤 7일 안에 든 계정을 찾는 창으로 후보를 찾는다") + void queriesCatchUpWindow() { + scheduler.remind(TODAY); + + // 삭제일 11/11~11/17 = 끝난 날 10/12~10/18. 끝난 시각 [10/12 0시, 10/19 0시). + verify(userRepository).findHomeReminderCandidates( + eq(LocalDateTime.of(2026, 10, 12, 0, 0)), eq(LocalDateTime.of(2026, 10, 19, 0, 0)), any()); + } + + @Test + @DisplayName("후보에게 남은 일수와 삭제일을 넣어 메일·DM으로 안내한다") + void notifiesCandidate() { + candidates(user(7L, "홍길동", "hong@dgu.ac.kr", "hong", ENDED_10_18)); + + scheduler.remind(TODAY); + + verify(messageUtils).get("notification.user.home-delete-reminder.subject", "7"); + verify(messageUtils).get("notification.user.home-delete-reminder.body", + "홍길동", "hong", "7", "2026-11-17"); + verify(alarmService).notifyUser(eq("홍길동"), eq("hong@dgu.ac.kr"), + eq("notification.user.home-delete-reminder.subject"), + eq("notification.user.home-delete-reminder.body")); + } + + @Test + @DisplayName("같은 주기·같은 단계의 안내가 이미 잡혀 있으면 다시 보내지 않는다") + void skipsAlreadyClaimed() { + candidates(user(7L, "홍길동", "hong@dgu.ac.kr", "hong", ENDED_10_18)); + when(valueOps.setIfAbsent(anyString(), any(), any(Duration.class))).thenReturn(false); + + scheduler.remind(TODAY); + + verify(alarmService, never()).notifyUser(anyString(), anyString(), anyString(), anyString()); + } + + @Test + @DisplayName("발송이 실패하면 키를 풀어, 다음 날 같은 단계로 다시 보낸다") + void releasesClaimWhenSendFailsAndRetriesNextDay() { + candidates(user(7L, "홍길동", "hong@dgu.ac.kr", "hong", ENDED_10_18)); + when(alarmService.notifyUser(anyString(), anyString(), anyString(), anyString())) + .thenReturn(false, true); + + scheduler.remind(TODAY); + verify(redisTemplate, times(1)).delete(anyString()); + + scheduler.remind(TODAY.plusDays(1)); + + verify(alarmService, times(2)).notifyUser(eq("홍길동"), eq("hong@dgu.ac.kr"), anyString(), anyString()); + } + + @Test + @DisplayName("발송이 성공했으면 키를 유지해 같은 단계는 다음 날 다시 보내지 않는다") + void sendsOnlyOnceAfterSuccess() { + candidates(user(7L, "홍길동", "hong@dgu.ac.kr", "hong", ENDED_10_18)); + when(valueOps.setIfAbsent(anyString(), any(), any(Duration.class))).thenReturn(true, false); + + scheduler.remind(TODAY); + scheduler.remind(TODAY.plusDays(1)); + + verify(alarmService, times(1)).notifyUser(anyString(), anyString(), anyString(), anyString()); + verify(redisTemplate, never()).delete(anyString()); + } + + @Test + @DisplayName("남은 날이 1일이면 D-1 안내 한 통만 보낸다") + void oneDayLeftSendsSingleNotice() { + candidates(user(7L, "홍길동", "hong@dgu.ac.kr", "hong", LocalDate.of(2026, 10, 12))); + + scheduler.remind(TODAY); + + verify(messageUtils).get("notification.user.home-delete-reminder.subject", "1"); + verify(alarmService, times(1)).notifyUser(anyString(), anyString(), anyString(), anyString()); + } + + @Test + @DisplayName("삭제일 당일이거나 지난 계정에게는 보내지 않는다") + void neverSendsOnOrAfterDeletionDate() { + candidates( + user(1L, "가", "a@dgu.ac.kr", "a", LocalDate.of(2026, 10, 11)), // 삭제일 = 오늘 + user(2L, "나", "b@dgu.ac.kr", "b", LocalDate.of(2026, 10, 1))); // 삭제일 = 10/31 + + scheduler.remind(TODAY); + + verify(alarmService, never()).notifyUser(anyString(), anyString(), anyString(), anyString()); + } + + @Test + @DisplayName("한 사용자의 발송이 실패해도 나머지에게는 보낸다") + void oneFailureDoesNotBlockOthers() { + candidates( + user(1L, "가", "a@dgu.ac.kr", "a", ENDED_10_18), + user(2L, "나", "b@dgu.ac.kr", "b", ENDED_10_18)); + doThrow(new RuntimeException("smtp down")).when(alarmService) + .notifyUser(eq("가"), anyString(), anyString(), anyString()); + + scheduler.remind(TODAY); + + verify(alarmService).notifyUser(eq("나"), eq("b@dgu.ac.kr"), anyString(), anyString()); + verify(redisTemplate, times(1)).delete(anyString()); + } + + @Test + @DisplayName("Redis에 닿지 못하면 중복 확인을 건너뛰고 보낸다") + void sendsWhenRedisIsDown() { + candidates(user(7L, "홍길동", "hong@dgu.ac.kr", "hong", ENDED_10_18)); + when(valueOps.setIfAbsent(anyString(), any(), any(Duration.class))).thenThrow(new RuntimeException("redis down")); + + scheduler.remind(TODAY); + + verify(alarmService).notifyUser(eq("홍길동"), anyString(), anyString(), anyString()); + } +} diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/RequestNotificationServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/RequestNotificationServiceTest.java index 9744e0d5..7e25a2c3 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/RequestNotificationServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/RequestNotificationServiceTest.java @@ -225,7 +225,7 @@ void continuesProcessing_whenAlarmServiceThrows() { .thenReturn(List.of(req1, req2)); when(messageUtils.get(anyString(), any(Object[].class))).thenReturn("mock"); doThrow(new RuntimeException("Slack error")) - .doNothing() + .doReturn(true) .when(alarmService).notifyUser(any(), any(), any(), any()); notificationService.sendPreExpiryNotification(LocalDateTime.now(), "3일"); diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/UserLifecycleTransactionalServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/UserLifecycleTransactionalServiceTest.java index f9a12420..dd671114 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/UserLifecycleTransactionalServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/UserLifecycleTransactionalServiceTest.java @@ -53,6 +53,9 @@ class UserLifecycleTransactionalServiceTest { @Mock private InactivityNoticeStore noticeStore; + @Mock + private DGU_AI_LAB.admin_be.domain.home.service.HomeRetentionPolicy homeRetentionPolicy; + @Mock @SuppressWarnings("rawtypes") private ValueOperations valueOps; @@ -94,6 +97,84 @@ private User buildUser(LocalDateTime createdAt, LocalDateTime lastLoginAt) { private static final LocalDateTime NOW = LocalDateTime.of(2026, 1, 10, 9, 0); + @Nested + @DisplayName("processInactiveUser - 졸업 예정일 규칙") + class GraduationRule { + + private User graduating(LocalDateTime createdAt, java.time.LocalDate graduationDate) { + User user = buildUser(createdAt, null); + ReflectionTestUtils.setField(user, "expectedGraduationDate", graduationDate); + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + return user; + } + + @Test + @DisplayName("졸업 예정일 + 30일의 7일 전에 졸업 안내 경고를 보낸다 — 가입이 1년 안이어도") + void warnsSevenDaysBeforeGraduationDeadline() { + graduating(NOW.minusDays(10), NOW.toLocalDate().plusDays(7).minusDays(30)); + + boolean deactivate = lifecycleService.processInactiveUser(1L, NOW); + + assertThat(deactivate).isFalse(); + verify(messageUtils).get(eq("notification.user.graduation-warning.subject"), any(Object[].class)); + verify(messageUtils).get(eq("notification.user.graduation-warning.body"), any(Object[].class)); + verify(alarmService).notifyUser(any(), any(), any(), any()); + } + + @Test + @DisplayName("졸업 예정일을 먼 미래로 미뤄도 1년 미사용 규칙이 먼저 적용된다 — 기한이 지나 안내한 예정일도 지났으면 비활성화") + void farFutureGraduationDoesNotBypassOneYearRule() { + graduating(NOW.minusYears(2), NOW.toLocalDate().plusYears(6)); + + assertThat(lifecycleService.processInactiveUser(1L, NOW)).isTrue(); + } + + @Test + @DisplayName("졸업 예정일이 더 늦으면 1년 규칙의 경고(7일 전)를 1년 규칙 문구로 보낸다") + void laterGraduationUsesOneYearWarning() { + graduating(NOW.plusDays(7).minusYears(1), NOW.toLocalDate().plusYears(5)); + + assertThat(lifecycleService.processInactiveUser(1L, NOW)).isFalse(); + + verify(messageUtils).get(eq("notification.user.delete-warning.body"), any(Object[].class)); + verify(messageUtils, never()).get(eq("notification.user.graduation-warning.body"), any(Object[].class)); + } + + @Test + @DisplayName("졸업 규칙의 기한이 더 이르면 졸업 규칙이 적용된다 — 1년 규칙 기한이 남아 있어도") + void earlierGraduationWins() { + graduating(NOW.minusDays(10), NOW.toLocalDate().minusDays(30)); + + assertThat(lifecycleService.processInactiveUser(1L, NOW)).isTrue(); + } + + @Test + @DisplayName("졸업 예정일이 없으면 1년 규칙만 적용된다") + void nullGraduationUsesOneYearRuleOnly() { + graduating(NOW.minusDays(10), null); + + assertThat(lifecycleService.processInactiveUser(1L, NOW)).isFalse(); + verifyNoInteractions(alarmService); + } + + @Test + @DisplayName("졸업 예정일 + 30일이 지나고 안내한 예정일도 지났으면 비활성화한다") + void deactivatesAfterGraduationDeadline() { + graduating(NOW.minusDays(10), NOW.toLocalDate().minusDays(30)); + + assertThat(lifecycleService.processInactiveUser(1L, NOW)).isTrue(); + } + + @Test + @DisplayName("두 규칙 모두 기한이 멀면 졸업 예정일이 있어도 아무 일도 하지 않는다") + void nothingWhenBothRulesAreFar() { + graduating(NOW.minusDays(10), NOW.toLocalDate().plusYears(1)); + + assertThat(lifecycleService.processInactiveUser(1L, NOW)).isFalse(); + verify(alarmService, never()).notifyUser(any(), any(), any(), any()); + } + } + @Nested @DisplayName("processInactiveUser - 경고 알림 중복 방지") class WarningDeduplication { @@ -182,7 +263,7 @@ void overdueWithoutNotice_getsGraceWarning() { verify(noticeStore).save(1L, NOW.toLocalDate().plusDays(7), NOW.toLocalDate()); verify(messageUtils).get("notification.user.delete-warning.body", - "홍길동", "7", NOW.toLocalDate().plusDays(7).toString()); + "홍길동", "7", NOW.toLocalDate().plusDays(7).toString(), "0"); verify(alarmService, times(1)).notifyUser(any(), any(), any(), any()); } diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/UserSchedulerServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/UserSchedulerServiceTest.java index 70b722df..a5fb6663 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/UserSchedulerServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/UserSchedulerServiceTest.java @@ -91,7 +91,7 @@ void userLifecycleScheduler_IntegrationTest() { setCreatedAt(d7User, d7Since); String d7Subject = messageUtils.get("notification.user.delete-warning.subject", "7"); String d7Body = messageUtils.get("notification.user.delete-warning.body", - "D7User", "7", d7Since.plusMonths(12).toLocalDate().toString()); + "D7User", "7", d7Since.plusMonths(12).toLocalDate().toString(), "30"); // 4. [경고 대상 D-1] User d1User = createUser("d1@test.com", "D1User"); @@ -99,7 +99,7 @@ void userLifecycleScheduler_IntegrationTest() { setCreatedAt(d1User, d1Since); String d1Subject = messageUtils.get("notification.user.delete-warning.subject", "1"); String d1Body = messageUtils.get("notification.user.delete-warning.body", - "D1User", "1", d1Since.plusMonths(12).toLocalDate().toString()); + "D1User", "1", d1Since.plusMonths(12).toLocalDate().toString(), "30"); // 5. [탈퇴 대상] 어제 로그인했어도 가입(컨테이너 사용 없음) 1년이 지났다 User softTarget = createUser("soft@test.com", "SoftTarget"); diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/controller/AuthControllerTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/controller/AuthControllerTest.java index 7d50ba12..f83412d3 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/controller/AuthControllerTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/controller/AuthControllerTest.java @@ -101,7 +101,7 @@ void register_returns200_whenSuccess() throws Exception { doNothing().when(userLoginService).register(any()); UserRegisterRequestDTO dto = new UserRegisterRequestDTO( - "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null + "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null, java.time.LocalDate.now().plusMonths(6) ); mockMvc.perform(post("/api/auth/register") @@ -114,7 +114,7 @@ void register_returns200_whenSuccess() throws Exception { @DisplayName("이메일 형식이 잘못되면 400 Bad Request를 반환한다") void register_returns400_whenEmailInvalid() throws Exception { UserRegisterRequestDTO dto = new UserRegisterRequestDTO( - "invalid-email", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null + "invalid-email", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null, java.time.LocalDate.now().plusMonths(6) ); mockMvc.perform(post("/api/auth/register") @@ -130,7 +130,7 @@ void register_returns409_whenEmailAlreadyExists() throws Exception { .when(userLoginService).register(any()); UserRegisterRequestDTO dto = new UserRegisterRequestDTO( - "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null + "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null, java.time.LocalDate.now().plusMonths(6) ); mockMvc.perform(post("/api/auth/register") diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/dto/request/GraduationDtoValidationTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/dto/request/GraduationDtoValidationTest.java new file mode 100644 index 00000000..1c860fcf --- /dev/null +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/dto/request/GraduationDtoValidationTest.java @@ -0,0 +1,54 @@ +package DGU_AI_LAB.admin_be.domain.users.dto.request; + +import jakarta.validation.ConstraintViolation; +import jakarta.validation.Validation; +import jakarta.validation.Validator; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.time.LocalDate; +import java.util.Set; +import java.util.stream.Collectors; + +import static org.assertj.core.api.Assertions.assertThat; + +@DisplayName("졸업 예정일 입력 검증") +class GraduationDtoValidationTest { + + private static final Validator VALIDATOR = Validation.buildDefaultValidatorFactory().getValidator(); + + private static Set violatedPaths(T dto) { + return VALIDATOR.validate(dto).stream() + .map(ConstraintViolation::getPropertyPath).map(Object::toString).collect(Collectors.toSet()); + } + + private static UserRegisterRequestDTO signup(LocalDate graduation) { + return new UserRegisterRequestDTO("user@dgu.ac.kr", "strongPassword123!", "홍길동", "컴퓨터공학과", + "202312345", "010-1234-5678", "hongildong", null, graduation); + } + + @Test + @DisplayName("가입은 졸업 예정일이 필수이고 지난 날짜는 받지 않는다") + void signupRequiresFutureGraduationDate() { + assertThat(violatedPaths(signup(null))).contains("expectedGraduationDate"); + assertThat(violatedPaths(signup(LocalDate.now().minusDays(1)))).contains("expectedGraduationDate"); + assertThat(violatedPaths(signup(LocalDate.now().plusMonths(6)))).doesNotContain("expectedGraduationDate"); + } + + @Test + @DisplayName("졸업 예정일 입력 요청도 필수이고 지난 날짜는 받지 않는다") + void updateRequiresFutureGraduationDate() { + assertThat(violatedPaths(new GraduationUpdateRequestDTO(null))).contains("expectedGraduationDate"); + assertThat(violatedPaths(new GraduationUpdateRequestDTO(LocalDate.now().minusDays(1)))).contains("expectedGraduationDate"); + assertThat(violatedPaths(new GraduationUpdateRequestDTO(LocalDate.now()))).isEmpty(); + } + + @Test + @DisplayName("오늘부터 6년을 넘는 졸업 예정일은 가입·입력 모두 받지 않는다") + void rejectsTooFarDate() { + LocalDate edge = LocalDate.now().plusYears(6); + assertThat(violatedPaths(signup(edge))).doesNotContain("expectedGraduationDate"); + assertThat(violatedPaths(signup(edge.plusDays(1)))).contains("expectedGraduationDate"); + assertThat(violatedPaths(new GraduationUpdateRequestDTO(LocalDate.of(2099, 1, 1)))).contains("expectedGraduationDate"); + } +} diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/dto/request/UserRegisterRequestDTOTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/dto/request/UserRegisterRequestDTOTest.java index d497dcc3..08f7e477 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/dto/request/UserRegisterRequestDTOTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/dto/request/UserRegisterRequestDTOTest.java @@ -1,5 +1,6 @@ package DGU_AI_LAB.admin_be.domain.users.dto.request; +import DGU_AI_LAB.admin_be.support.UserRegisterRequests; import jakarta.validation.ConstraintViolation; import jakarta.validation.Validation; import jakarta.validation.Validator; @@ -36,7 +37,7 @@ static void tearDownValidator() { private UserRegisterRequestDTO valid() { return new UserRegisterRequestDTO( "user@dgu.ac.kr", "strongPassword123!", "이소은", - "컴퓨터공학과", "202312345", "010-1234-5678", "sochoi", null); + "컴퓨터공학과", "202312345", "010-1234-5678", "sochoi", null, java.time.LocalDate.now().plusMonths(6)); } private String repeat(int length) { @@ -52,7 +53,7 @@ void validRequest_hasNoViolations() { @Test @DisplayName("글자 수는 72자 이하여도 UTF-8로 72바이트를 넘는 비밀번호는 위반이다(BCrypt 한도)") void password_over72Bytes_isRejected() { - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "user@dgu.ac.kr", "가".repeat(25), "이소은", "컴퓨터공학과", "202312345", "010-1234-5678", "sochoi", null); @@ -62,7 +63,7 @@ void password_over72Bytes_isRejected() { @Test @DisplayName("UTF-8로 정확히 72바이트인 비밀번호는 통과한다") void password_exactly72Bytes_isAccepted() { - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "user@dgu.ac.kr", "가".repeat(24), "이소은", "컴퓨터공학과", "202312345", "010-1234-5678", "sochoi", null); @@ -72,7 +73,7 @@ void password_exactly72Bytes_isAccepted() { @Test @DisplayName("name이 100자를 넘으면 위반이 발생한다") void name_over100_isRejected() { - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "user@dgu.ac.kr", "pw", repeat(101), "컴퓨터공학과", "202312345", "010-1234-5678", "sochoi", null); @@ -100,7 +101,7 @@ void name_ordinary_isAccepted() { @Test @DisplayName("department가 100자를 넘으면 위반이 발생한다") void department_over100_isRejected() { - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "user@dgu.ac.kr", "pw", "이소은", repeat(101), "202312345", "010-1234-5678", "sochoi", null); @@ -110,7 +111,7 @@ void department_over100_isRejected() { @Test @DisplayName("studentId가 100자를 넘으면 위반이 발생한다") void studentId_over100_isRejected() { - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "user@dgu.ac.kr", "pw", "이소은", "컴퓨터공학과", repeat(101), "010-1234-5678", "sochoi", null); @@ -120,7 +121,7 @@ void studentId_over100_isRejected() { @Test @DisplayName("phone이 100자를 넘으면 위반이 발생한다") void phone_over100_isRejected() { - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "user@dgu.ac.kr", "pw", "이소은", "컴퓨터공학과", "202312345", repeat(101), "sochoi", null); @@ -130,7 +131,7 @@ void phone_over100_isRejected() { @Test @DisplayName("email이 100자를 넘으면 위반이 발생한다") void email_over100_isRejected() { - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( repeat(95) + "@dgu.ac.kr", "pw", "이소은", "컴퓨터공학과", "202312345", "010-1234-5678", "sochoi", null); @@ -140,7 +141,7 @@ void email_over100_isRejected() { @Test @DisplayName("password가 255자를 넘으면 위반이 발생한다") void password_over255_isRejected() { - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "user@dgu.ac.kr", repeat(256), "이소은", "컴퓨터공학과", "202312345", "010-1234-5678", "sochoi", null); @@ -152,7 +153,7 @@ void password_over255_isRejected() { void exactly100_isAccepted() { UserRegisterRequestDTO dto = new UserRegisterRequestDTO( "user@dgu.ac.kr", repeat(72), repeat(100), - repeat(100), repeat(100), "010-1234-5678", "a".repeat(32), null); + repeat(100), repeat(100), "010-1234-5678", "a".repeat(32), null, java.time.LocalDate.now().plusMonths(6)); assertThat(validator.validate(dto)).isEmpty(); } @@ -160,10 +161,10 @@ void exactly100_isAccepted() { @Test @DisplayName("password가 8자 미만이거나 72자를 넘으면 위반이 발생한다 (BCrypt는 72바이트까지만 쓴다)") void password_lengthBounds() { - assertThat(violatedFields(new UserRegisterRequestDTO( + assertThat(violatedFields(UserRegisterRequests.of( "user@dgu.ac.kr", repeat(7), "이소은", "컴퓨터공학과", "202312345", "010-1234-5678", "sochoi", null))) .contains("password"); - assertThat(violatedFields(new UserRegisterRequestDTO( + assertThat(violatedFields(UserRegisterRequests.of( "user@dgu.ac.kr", repeat(73), "이소은", "컴퓨터공학과", "202312345", "010-1234-5678", "sochoi", null))) .contains("password"); } @@ -171,7 +172,7 @@ void password_lengthBounds() { @Test @DisplayName("phone은 하이픈이 없어도 받고, 저장할 때 010-1234-5678 모양으로 맞춘다") void phone_acceptsDigitsOnly_andNormalizes() { - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "user@dgu.ac.kr", "strongPassword123!", "이소은", "컴퓨터공학과", "202312345", "01012345678", "sochoi", null); assertThat(violatedFields(dto)).doesNotContain("phone"); @@ -182,7 +183,7 @@ void phone_acceptsDigitsOnly_andNormalizes() { @DisplayName("phone에 숫자가 아닌 글자나 모자란 자리가 있으면 거절한다") void phone_rejectsMalformed() { for (String phone : new String[]{"010-12-5678", "전화번호", "1012345678", "010.1234.5678"}) { - assertThat(violatedFields(new UserRegisterRequestDTO( + assertThat(violatedFields(UserRegisterRequests.of( "user@dgu.ac.kr", "strongPassword123!", "이소은", "컴퓨터공학과", "202312345", phone, "sochoi", null))) .as(phone).contains("phone"); } @@ -191,7 +192,7 @@ void phone_rejectsMalformed() { @Test @DisplayName("기존 @NotBlank / @Email 제약은 그대로 동작한다") void existingConstraintsStillApply() { - UserRegisterRequestDTO blank = new UserRegisterRequestDTO( + UserRegisterRequestDTO blank = UserRegisterRequests.of( "not-an-email", " ".trim(), "", "", "", "", "", null); assertThat(violatedFields(blank)) @@ -201,7 +202,7 @@ void existingConstraintsStillApply() { @Test @DisplayName("ubuntuUsername이 3자 미만이면 위반이 발생한다") void ubuntuUsername_tooShort_isRejected() { - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "user@dgu.ac.kr", "pw", "이소은", "컴퓨터공학과", "202312345", "010-1234-5678", "ab", null); @@ -248,13 +249,13 @@ void ubuntuUsername_reportsSingleViolation() { } private UserRegisterRequestDTO registerWithUbuntuUsername(String ubuntuUsername) { - return new UserRegisterRequestDTO( + return UserRegisterRequests.of( "user@dgu.ac.kr", "strongPassword123!", "이소은", "컴퓨터공학과", "202312345", "010-1234-5678", ubuntuUsername, null); } private UserRegisterRequestDTO registerWithName(String name) { - return new UserRegisterRequestDTO( + return UserRegisterRequests.of( "user@dgu.ac.kr", "strongPassword123!", name, "컴퓨터공학과", "202312345", "010-1234-5678", "sochoi", null); } diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/entity/UserTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/entity/UserTest.java index 2bb2540b..7756f958 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/entity/UserTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/entity/UserTest.java @@ -226,4 +226,16 @@ void withdraw_setsInactiveAndDeletedAt() { assertThat(user.getDeletedAt()).isNotNull(); } } + + @Test + @DisplayName("reactivate: 지난 졸업 예정일이 남아 곧바로 다시 비활성화되지 않도록 졸업 예정일을 비운다") + void reactivateClearsGraduationDate() { + user.updateExpectedGraduationDate(java.time.LocalDate.of(2026, 1, 1)); + user.withdraw(); + + user.reactivate(); + + assertThat(user.getIsActive()).isTrue(); + assertThat(user.getExpectedGraduationDate()).isNull(); + } } diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepositoryTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepositoryTest.java index 323e00df..7030ad14 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepositoryTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepositoryTest.java @@ -16,6 +16,7 @@ import org.springframework.test.context.ActiveProfiles; import org.springframework.test.util.ReflectionTestUtils; +import java.time.LocalDate; import java.time.LocalDateTime; import java.util.List; import java.util.Optional; @@ -122,6 +123,18 @@ void findInactiveUsers_returnsUsersSignedUpBeforeThreshold() { assertThat(result).extracting(User::getEmail).contains("active@dgu.ac.kr"); } + @Test + @DisplayName("졸업 예정일이 있어도 조회한다 — 졸업 예정일을 미뤄 1년 규칙을 피할 수 없다") + void findInactiveUsers_includesUsersWithGraduationDate() { + user1.updateExpectedGraduationDate(LocalDate.now().plusYears(1)); + userRepository.saveAndFlush(user1); + setCreatedAt(user1, LocalDateTime.now().minusYears(2)); + + List result = userRepository.findInactiveUsers(LocalDateTime.now().minusYears(1), Status.openStatuses()); + + assertThat(result).extracting(User::getEmail).contains("active@dgu.ac.kr"); + } + @Test @DisplayName("관리자는 조회하지 않는다") void findInactiveUsers_excludesAdmins() { @@ -161,6 +174,146 @@ void findInactiveUsers_excludesRecentSignups() { } } + @Nested + @DisplayName("findGraduatingUsers") + class FindGraduatingUsers { + + private final LocalDate today = LocalDate.of(2026, 11, 9); + + private void graduate(User user, LocalDate date) { + user.updateExpectedGraduationDate(date); + userRepository.saveAndFlush(user); + } + + @Test + @DisplayName("졸업 예정일이 기준일보다 이른 활성 일반 사용자만 조회한다") + void returnsOnlyBeforeCutoff() { + graduate(user1, today.minusDays(31)); + graduate(user2, today); + + List result = userRepository.findGraduatingUsers(today, Status.openStatuses()); + + assertThat(result).extracting(User::getEmail).containsExactly("active@dgu.ac.kr"); + } + + @Test + @DisplayName("졸업 예정일이 없거나 관리자거나 비활성이면 조회하지 않는다") + void excludesNullAdminInactive() { + graduate(user2, today.minusDays(40)); + user2.changeRole(Role.ADMIN); + userRepository.saveAndFlush(user2); + // user1: 졸업 예정일 없음 + User inactive = userRepository.save(User.builder().email("off@dgu.ac.kr").password("p") + .name("비활성").studentId("2021009999").phone("010-9999-9999").department("컴퓨터공학과").build()); + graduate(inactive, today.minusDays(40)); + inactive.deactivate(); + userRepository.saveAndFlush(inactive); + + assertThat(userRepository.findGraduatingUsers(today, Status.openStatuses())).isEmpty(); + } + + @Test + @DisplayName("끝나지 않은 신청이 있으면 조회하지 않는다") + void excludesOpenRequests() { + graduate(user1, today.minusDays(40)); + persistRequest(user1); + + assertThat(userRepository.findGraduatingUsers(today, Status.openStatuses())).isEmpty(); + } + } + + @Nested + @DisplayName("findHomeReminderCandidates") + class FindHomeReminderCandidates { + + private final LocalDateTime from = LocalDateTime.of(2026, 10, 1, 0, 0); + private final LocalDateTime to = LocalDateTime.of(2026, 10, 2, 0, 0); + + private void withAccount(User user) { + user.assignUbuntuAccount(60001L + user.getUserId(), 60001L + user.getUserId()); + ReflectionTestUtils.setField(user, "ubuntuUsername", "u" + user.getUserId()); + userRepository.saveAndFlush(user); + } + + private Long deletedRequest(User user, LocalDateTime endedAt) { + Long id = persistRequest(user); + entityManager.getEntityManager() + .createNativeQuery("UPDATE requests SET status = 'DELETED', approved_at = :t, updated_at = :t WHERE request_id = :id") + .setParameter("t", endedAt).setParameter("id", id).executeUpdate(); + entityManager.clear(); + return id; + } + + @Test + @DisplayName("마지막 컨테이너가 [from, to) 안에 끝난 사용자만 조회한다") + void windowIsHalfOpen() { + withAccount(user1); + withAccount(user2); + deletedRequest(user1, from); // 포함(경계) + deletedRequest(user2, to); // 제외(상한 미포함) + + List result = userRepository.findHomeReminderCandidates(from, to, Status.openStatuses()); + + assertThat(result).extracting(User::getEmail).containsExactly("active@dgu.ac.kr"); + // 안내 후보는 삭제 후보의 부분집합이어야 한다 — 두 질의의 공통 조건이 어긋나면 여기서 드러난다. + assertThat(userRepository.findHomeCleanupCandidates(to.plusDays(1), Status.openStatuses())) + .containsAll(result); + } + + @Test + @DisplayName("더 나중에 끝난 컨테이너가 있으면 마지막 시각이 창 밖이라 조회하지 않는다") + void usesLatestEnd() { + withAccount(user1); + deletedRequest(user1, from.plusHours(1)); + deletedRequest(user1, to.plusDays(5)); + + assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses())).isEmpty(); + } + + @Test + @DisplayName("계정이 없거나 끝나지 않은 신청이 있거나 탈퇴한 사용자는 조회하지 않는다") + void excludes() { + deletedRequest(user1, from.plusHours(1)); // 계정 없음 + withAccount(user2); + deletedRequest(user2, from.plusHours(1)); + persistRequest(user2); // 열린 신청 + assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses())).isEmpty(); + + User gone = userRepository.save(User.builder().email("gone@dgu.ac.kr").password("p") + .name("탈퇴").studentId("2021008888").phone("010-8888-8888").department("컴퓨터공학과").build()); + withAccount(gone); + deletedRequest(gone, from.plusHours(1)); + gone = userRepository.findById(gone.getUserId()).orElseThrow(); + gone.withdraw(); + userRepository.saveAndFlush(gone); + assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses())).isEmpty(); + } + + @Test + @DisplayName("비활성화된 사용자에게는 안내하지 않는다") + void excludesInactive() { + withAccount(user1); + deletedRequest(user1, from.plusHours(1)); + user1 = userRepository.findById(user1.getUserId()).orElseThrow(); + user1.deactivate(); + userRepository.saveAndFlush(user1); + + assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses())).isEmpty(); + } + } + + private Long persistRequest(User user) { + ResourceGroup rg = entityManager.persist(ResourceGroup.builder() + .resourceGroupName("rg" + System.nanoTime()).description("GPU").serverName("FARM").build()); + ContainerImage image = entityManager.persist(ContainerImage.builder() + .imageName("img" + System.nanoTime()).imageVersion("1").cudaVersion("11.8").description("d").build()); + Request r = entityManager.persist(Request.builder() + .expiresAt(LocalDateTime.now().plusDays(30)).usagePurpose("연구").formAnswers("{}") + .user(user).resourceGroup(rg).containerImage(image).build()); + entityManager.flush(); + return r.getRequestId(); + } + @Nested @DisplayName("replaceWeakUbuntuPasswordHash") class ReplaceWeakUbuntuPasswordHash { diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserServiceTest.java index 1cbbe8d9..1365bda3 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserServiceTest.java @@ -52,6 +52,9 @@ @ExtendWith(MockitoExtension.class) class AdminUserServiceTest { + @Mock + private DGU_AI_LAB.admin_be.domain.home.service.HomeRetentionPolicy homeRetentionPolicy; + @InjectMocks private AdminUserService adminUserService; @@ -375,6 +378,77 @@ void withdrawsAndStartsRevoke() { verify(messageUtils).get("notification.user.soft-delete.subject"); } + private void withdrawWithGraduation(java.time.LocalDate graduationDate) { + mockUser.updateExpectedGraduationDate(graduationDate); + givenRequests(); + adminUserService.withdrawInactiveUser(1L); + } + + @Test + @DisplayName("졸업 예정일이 없으면 1년 미사용 안내 문구를 쓴다") + void noGraduationDate_usesInactivityNotice() { + withdrawWithGraduation(null); + + verify(messageUtils).get(eq("notification.user.soft-delete.subject")); + verify(messageUtils, never()).get(eq("notification.user.soft-delete.graduation.subject")); + } + + @Test + @DisplayName("졸업 예정일이 먼 미래라 1년 미사용으로 비활성화되면 1년 미사용 안내 문구를 쓴다") + void farFutureGraduation_usesInactivityNotice() { + withdrawWithGraduation(java.time.LocalDate.now().plusYears(5)); + + verify(messageUtils).get(eq("notification.user.soft-delete.subject")); + verify(messageUtils, never()).get(eq("notification.user.soft-delete.graduation.subject")); + } + + @Test + @DisplayName("졸업 예정일 + 30일이 아직 안 지났으면(내일) 1년 미사용 안내 문구를 쓴다") + void graceNotYetOver_usesInactivityNotice() { + withdrawWithGraduation(java.time.LocalDate.now().minusDays(30).plusDays(1)); + + verify(messageUtils).get(eq("notification.user.soft-delete.subject")); + verify(messageUtils, never()).get(eq("notification.user.soft-delete.graduation.subject")); + } + + @Test + @DisplayName("졸업 예정일 + 30일이 정확히 오늘이면 졸업 안내 문구를 쓴다 (경계)") + void graceEndsToday_usesGraduationNotice() { + withdrawWithGraduation(java.time.LocalDate.now().minusDays(30)); + + verify(messageUtils).get(eq("notification.user.soft-delete.graduation.subject")); + verify(messageUtils, never()).get(eq("notification.user.soft-delete.subject")); + } + + @Test + @DisplayName("졸업 예정일 + 30일이 이미 지났으면 졸업 안내 문구를 쓴다") + void gracePassed_usesGraduationNotice() { + withdrawWithGraduation(java.time.LocalDate.now().minusDays(60)); + + verify(messageUtils).get(eq("notification.user.soft-delete.graduation.subject")); + verify(messageUtils, never()).get(eq("notification.user.soft-delete.subject")); + } + + @Test + @DisplayName("졸업 기한(+30일)이 1년 미사용 기한보다 먼저 지났으면 졸업 안내 문구를 쓴다") + void graduationEarlierThanInactivity_usesGraduationNotice() { + ReflectionTestUtils.setField(mockUser, "createdAt", java.time.LocalDateTime.now().minusMonths(13)); + withdrawWithGraduation(java.time.LocalDate.now().minusDays(70)); + + verify(messageUtils).get(eq("notification.user.soft-delete.graduation.subject")); + verify(messageUtils, never()).get(eq("notification.user.soft-delete.subject")); + } + + @Test + @DisplayName("졸업 기한이 지났어도 1년 미사용 기한이 먼저면 1년 미사용 안내 문구를 쓴다") + void inactivityEarlierThanGraduation_usesInactivityNotice() { + ReflectionTestUtils.setField(mockUser, "createdAt", java.time.LocalDateTime.now().minusMonths(13)); + withdrawWithGraduation(java.time.LocalDate.now().minusDays(40)); + + verify(messageUtils).get(eq("notification.user.soft-delete.subject")); + verify(messageUtils, never()).get(eq("notification.user.soft-delete.graduation.subject")); + } + @Test @DisplayName("그 사이 이미 비활성화된 유저는 건너뛴다") void skipsInactiveUser() { diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserServiceWithdrawInactiveIntegrationTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserServiceWithdrawInactiveIntegrationTest.java new file mode 100644 index 00000000..2e2653c2 --- /dev/null +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserServiceWithdrawInactiveIntegrationTest.java @@ -0,0 +1,81 @@ +package DGU_AI_LAB.admin_be.domain.users.service; + +import DGU_AI_LAB.admin_be.domain.alarm.service.AlarmService; +import DGU_AI_LAB.admin_be.domain.groups.service.PendingGroupService; +import DGU_AI_LAB.admin_be.domain.home.service.HomeRetentionPolicy; +import DGU_AI_LAB.admin_be.domain.requests.service.PodMigrationService; +import DGU_AI_LAB.admin_be.domain.requests.service.RequestExpiryService; +import DGU_AI_LAB.admin_be.domain.users.entity.User; +import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; +import DGU_AI_LAB.admin_be.global.util.MessageUtils; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.context.annotation.Import; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.bean.override.mockito.MockitoBean; +import org.springframework.transaction.annotation.Propagation; +import org.springframework.transaction.annotation.Transactional; + +import java.time.LocalDate; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.verify; + +/** + * withdrawInactiveUser가 DB에서 읽은 실제 사용자(requests가 지연 로딩)로 끝까지 가는지 본다. 단위 테스트의 mock 사용자는 + * requests가 일반 리스트라 트랜잭션 밖 판정에서 나던 LazyInitializationException을 잡지 못했다. + * 서비스가 자기 트랜잭션을 쓰도록 테스트 트랜잭션을 끄고, 픽스처는 커밋한 뒤 정리한다. + */ +@DataJpaTest +@ActiveProfiles("test") +@Import(AdminUserService.class) +@Transactional(propagation = Propagation.NOT_SUPPORTED) +class AdminUserServiceWithdrawInactiveIntegrationTest { + + @Autowired private AdminUserService service; + @Autowired private UserRepository userRepository; + @MockitoBean private RequestExpiryService requestExpiryService; + @MockitoBean private PodMigrationService podMigrationService; + @MockitoBean private PendingGroupService pendingGroupService; + @MockitoBean private AlarmService alarmService; + @MockitoBean private MessageUtils messageUtils; + @MockitoBean private TokenService tokenService; + @MockitoBean private PasswordResetService passwordResetService; + @MockitoBean private InactivityNoticeStore inactivityNoticeStore; + @MockitoBean private HomeRetentionPolicy homeRetentionPolicy; + + @AfterEach + void cleanup() { + userRepository.deleteAll(); + } + + @Test + @DisplayName("졸업 예정일이 없는 장기 미사용 사용자는 비활성화되고 장기 미사용 안내를 받는다") + void withdrawsPersistedInactiveUser() { + Long userId = saveUser("inactive@dgu.ac.kr", "2099003333", null); + + service.withdrawInactiveUser(userId); + + assertThat(userRepository.findById(userId).orElseThrow().getIsActive()).isFalse(); + verify(messageUtils).get("notification.user.soft-delete.subject"); + } + + @Test + @DisplayName("졸업 기한이 지난 사용자는 비활성화되고 졸업 안내를 받는다") + void withdrawsPersistedGraduatedUser() { + Long userId = saveUser("graduated@dgu.ac.kr", "2099004444", LocalDate.of(2020, 2, 28)); + + service.withdrawInactiveUser(userId); + + assertThat(userRepository.findById(userId).orElseThrow().getIsActive()).isFalse(); + verify(messageUtils).get("notification.user.soft-delete.graduation.subject"); + } + + private Long saveUser(String email, String studentId, LocalDate graduation) { + return userRepository.save(User.builder().email(email).password("p").name("이름").studentId(studentId) + .phone("010-1111-4444").department("컴퓨터공학과").expectedGraduationDate(graduation).build()).getUserId(); + } +} diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserLoginServiceLoggingTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserLoginServiceLoggingTest.java index 6157e438..81925986 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserLoginServiceLoggingTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserLoginServiceLoggingTest.java @@ -3,6 +3,7 @@ import DGU_AI_LAB.admin_be.global.auth.EmailDomainPolicy; import DGU_AI_LAB.admin_be.global.validation.ReservedLinuxNames; import DGU_AI_LAB.admin_be.domain.users.dto.request.UserRegisterRequestDTO; +import DGU_AI_LAB.admin_be.support.UserRegisterRequests; import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository; import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; import DGU_AI_LAB.admin_be.global.auth.jwt.JwtProvider; @@ -58,7 +59,7 @@ class UserLoginServiceLoggingTest { @Test @DisplayName("회원가입 완료 로그에 이메일 주소가 남지 않는다") void doesNotLogEmailOnRegister() { - UserRegisterRequestDTO request = new UserRegisterRequestDTO( + UserRegisterRequestDTO request = UserRegisterRequests.of( EMAIL, "rawPassword1!", "김신입", "컴퓨터공학과", "2024001234", "010-9999-8888", "kimsinip", null); when(redisTemplate.hasKey("VERIFIED:" + EMAIL)).thenReturn(true); diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserLoginServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserLoginServiceTest.java index faa17e44..ad4386c6 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserLoginServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserLoginServiceTest.java @@ -4,6 +4,7 @@ import DGU_AI_LAB.admin_be.global.auth.EmailDomainPolicy; import DGU_AI_LAB.admin_be.domain.users.dto.request.UserLoginRequestDTO; import DGU_AI_LAB.admin_be.domain.users.dto.request.UserRegisterRequestDTO; +import DGU_AI_LAB.admin_be.support.UserRegisterRequests; import DGU_AI_LAB.admin_be.domain.users.dto.response.UserTokenResponseDTO; import DGU_AI_LAB.admin_be.domain.users.entity.User; import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository; @@ -100,7 +101,7 @@ void register_mixedCaseEmail_usesLowercaseVerifiedKey() { when(userRepository.findByEmail("Test@dgu.ac.kr")).thenReturn(Optional.empty()); when(passwordEncoder.encode(anyString())).thenReturn("encodedPw"); - userLoginService.register(new UserRegisterRequestDTO( + userLoginService.register(UserRegisterRequests.of( "Test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null )); @@ -115,7 +116,7 @@ void register_success() { when(userRepository.findByEmail("test@dgu.ac.kr")).thenReturn(Optional.empty()); when(passwordEncoder.encode(anyString())).thenReturn("encodedPw"); - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null ); @@ -138,7 +139,7 @@ void register_throwsException_whenUbuntuUsernameTaken() { when(userRepository.findByEmail("test@dgu.ac.kr")).thenReturn(Optional.empty()); when(userRepository.existsByUbuntuUsername("honggildong")).thenReturn(true); - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null ); @@ -156,7 +157,7 @@ void register_throwsException_whenUbuntuUsernameReserved() { when(userRepository.findByEmail("test@dgu.ac.kr")).thenReturn(Optional.empty()); when(reservedLinuxNames.contains("www-data")).thenReturn(true); - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "www-data", null ); @@ -175,7 +176,7 @@ void register_throwsException_whenUbuntuUsernameEqualsGroupName() { when(userRepository.existsByUbuntuUsername("developers")).thenReturn(false); when(groupRepository.existsByGroupName("developers")).thenReturn(true); - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "developers", null ); @@ -196,7 +197,7 @@ void register_mapsUbuntuUsernameViolationToDuplicateUsername() { .thenThrow(new DataIntegrityViolationException("constraint violation", new RuntimeException("Duplicate entry 'honggildong' for key 'uk_users_ubuntu_username'"))); - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null ); @@ -217,7 +218,7 @@ void register_mapsUniqueViolationToAlreadyExists() { when(userRepository.saveAndFlush(any(User.class))) .thenThrow(new DataIntegrityViolationException("uk_users_email")); - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null ); @@ -234,7 +235,7 @@ void register_mapsUniqueViolationToAlreadyExists() { void register_throwsException_whenEmailNotVerified() { when(redisTemplate.hasKey("VERIFIED:test@dgu.ac.kr")).thenReturn(false); - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null ); @@ -248,7 +249,7 @@ void register_throwsException_whenEmailAlreadyExists() { when(redisTemplate.hasKey("VERIFIED:test@dgu.ac.kr")).thenReturn(true); when(userRepository.findByEmail("test@dgu.ac.kr")).thenReturn(Optional.of(activeUser)); - UserRegisterRequestDTO dto = new UserRegisterRequestDTO( + UserRegisterRequestDTO dto = UserRegisterRequests.of( "test@dgu.ac.kr", "password123", "홍길동", "컴퓨터공학과", "2021001234", "010-1234-5678", "honggildong", null ); diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserServiceTest.java index 63d6bc58..1c8960cc 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UserServiceTest.java @@ -2,6 +2,7 @@ import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository; +import DGU_AI_LAB.admin_be.domain.users.dto.request.GraduationUpdateRequestDTO; import DGU_AI_LAB.admin_be.domain.users.dto.request.PhoneUpdateRequestDTO; import DGU_AI_LAB.admin_be.domain.users.dto.request.UbuntuUsernameRegisterRequestDTO; import DGU_AI_LAB.admin_be.domain.users.dto.response.MyInfoResponseDTO; @@ -135,6 +136,32 @@ void updatePhone_throwsException_whenUserNotFound() { } + @Nested + @DisplayName("updateExpectedGraduationDate") + class UpdateExpectedGraduationDate { + + @Test + @DisplayName("졸업 예정일을 저장한다") + void saves() { + when(userRepository.findById(1L)).thenReturn(Optional.of(mockUser)); + java.time.LocalDate date = java.time.LocalDate.of(2027, 2, 26); + + userService.updateExpectedGraduationDate(1L, new GraduationUpdateRequestDTO(date)); + + assertThat(mockUser.getExpectedGraduationDate()).isEqualTo(date); + } + + @Test + @DisplayName("유저가 없으면 EntityNotFoundException을 던진다") + void throwsWhenUserNotFound() { + when(userRepository.findById(99L)).thenReturn(Optional.empty()); + + assertThatThrownBy(() -> userService.updateExpectedGraduationDate( + 99L, new GraduationUpdateRequestDTO(java.time.LocalDate.of(2027, 2, 26)))) + .isInstanceOf(EntityNotFoundException.class); + } + } + @Nested @DisplayName("registerUbuntuUsername") class RegisterUbuntuUsername { diff --git a/src/test/java/DGU_AI_LAB/admin_be/global/config/RuntimeDefaultsTest.java b/src/test/java/DGU_AI_LAB/admin_be/global/config/RuntimeDefaultsTest.java index 600e0d8b..fa1f0480 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/global/config/RuntimeDefaultsTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/global/config/RuntimeDefaultsTest.java @@ -43,7 +43,7 @@ void appliesDefaults() { assertThat(props.getProperty("mail.smtp.timeout")).isEqualTo("10000"); assertThat(props.getProperty("mail.smtp.writetimeout")).isEqualTo("10000"); assertThat(ctx.getBean(ThreadPoolTaskScheduler.class).getScheduledThreadPoolExecutor().getCorePoolSize()) - .isEqualTo(19); + .isEqualTo(20); } } diff --git a/src/test/java/DGU_AI_LAB/admin_be/global/util/MessagesPropertiesTest.java b/src/test/java/DGU_AI_LAB/admin_be/global/util/MessagesPropertiesTest.java index 36908a31..3c78b31c 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/global/util/MessagesPropertiesTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/global/util/MessagesPropertiesTest.java @@ -32,4 +32,18 @@ void everyTemplateFormats() throws Exception { assertThat(new MessageFormat(template, Locale.KOREA).format(args)).as(key).doesNotContain("{").doesNotContain("}"); } } + + @Test + @DisplayName("비활성화 안내문은 홈 폴더와 이력이 어떻게 되는지 알려 준다") + void inactivationNoticesExplainHomeAndHistory() throws Exception { + Properties messages = new Properties(); + try (var reader = new InputStreamReader( + getClass().getClassLoader().getResourceAsStream("messages.properties"), StandardCharsets.UTF_8)) { + messages.load(reader); + } + + for (String key : new String[]{"notification.user.delete-warning.body", "notification.user.soft-delete.body"}) { + assertThat(messages.getProperty(key)).as(key).contains("홈 폴더").contains("이력"); + } + } } diff --git a/src/test/java/DGU_AI_LAB/admin_be/global/util/UserNoticeRenderingTest.java b/src/test/java/DGU_AI_LAB/admin_be/global/util/UserNoticeRenderingTest.java new file mode 100644 index 00000000..98fadd7e --- /dev/null +++ b/src/test/java/DGU_AI_LAB/admin_be/global/util/UserNoticeRenderingTest.java @@ -0,0 +1,115 @@ +package DGU_AI_LAB.admin_be.global.util; + +import DGU_AI_LAB.admin_be.domain.alarm.service.NotificationMailer; +import DGU_AI_LAB.admin_be.domain.messageTemplate.repository.MessageTemplateRepository; +import DGU_AI_LAB.admin_be.global.config.MessageSourceConfig; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.springframework.mail.SimpleMailMessage; +import org.springframework.mail.javamail.JavaMailSender; +import org.springframework.test.util.ReflectionTestUtils; + +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * 계정·홈 안내 메일을 배포본과 같은 경로(MessageSourceConfig → MessageUtils → NotificationMailer)로 만들어 + * 본문이 비지 않고, 값이 빠짐없이 들어가고, 홈 삭제 일수가 설정값을 따르고, 줄바꿈이 살아 있는지 고정한다. + */ +class UserNoticeRenderingTest { + + private static final String NAME = "홍길동"; + private static final String ANNOUNCED_DAYS = "45"; // 기본값(30)과 달라야 하드코딩을 잡는다 + private static final String FORM_URL = "https://forms.gle/nACaxj2UeJF56V2i7"; + + private MessageUtils messageUtils; + + @BeforeEach + void setUp() { + MessageTemplateRepository repository = mock(MessageTemplateRepository.class); + when(repository.findById(anyString())).thenReturn(Optional.empty()); // DB 양식이 없으면 messages.properties + messageUtils = new MessageUtils(new MessageSourceConfig(repository).dbMessageSource()); + } + + private void assertWellFormed(String key, String text) { + assertThat(text).as(key).isNotBlank() + .doesNotContainPattern("\\{\\d+}") // 채워지지 않은 자리표시자 + .doesNotContain("\\n") // 줄바꿈이 글자 그대로 남음 + .doesNotContain("30일") // 홈 삭제 일수 하드코딩 + .contains("\n\n"); // 문단 구분이 살아 있음 + assertThat(text.lines()).as(key + " 들여쓰기 잔류").noneMatch(line -> line.startsWith(" ")); + assertThat(text).as(key).startsWith("안녕하세요, " + NAME + "님."); + } + + @Test + @DisplayName("1년 미사용 경고: 남은 일수·예정일·홈 삭제 일수·재활성화 방법이 들어간다") + void deleteWarning() { + String body = messageUtils.get("notification.user.delete-warning.body", NAME, "7", "2026-12-01", ANNOUNCED_DAYS); + + assertWellFormed("delete-warning", body); + assertThat(body).contains("7일 뒤(2026-12-01)").contains("컨테이너를 쓴 지 45일이 지나면 삭제") + .contains("이력은 비활성화돼도 보존돼요").contains("컨테이너를 새로 신청해 주세요"); + assertThat(messageUtils.get("notification.user.delete-warning.subject", "7")).isEqualTo("[DGU AI LAB] 7일 뒤에 계정이 비활성화돼요"); + } + + @Test + @DisplayName("졸업 경고: 남은 일수·예정일·홈 삭제 일수가 들어가고 졸업이 미뤄졌을 때의 방법을 알려 준다") + void graduationWarning() { + String body = messageUtils.get("notification.user.graduation-warning.body", NAME, "1", "2027-03-28", ANNOUNCED_DAYS); + + assertWellFormed("graduation-warning", body); + assertThat(body).contains("졸업 예정일").contains("1일 뒤(2027-03-28)").contains("45일이 지나면 삭제") + .contains("이력은 비활성화돼도 보존돼요").contains("졸업 예정일을 바꿔 주세요"); + } + + @Test + @DisplayName("비활성화 완료(1년 미사용·졸업): 홈 삭제 일수·이력 보존·재활성화 방법(문의 폼)이 정확히 들어간다") + void softDeleteNotices() { + for (String key : new String[]{"notification.user.soft-delete", "notification.user.soft-delete.graduation"}) { + String body = messageUtils.get(key + ".body", NAME, ANNOUNCED_DAYS); + + assertWellFormed(key, body); + assertThat(body).as(key).contains("계정을 비활성화했어요").contains("로그인할 수 없고") + .contains("컨테이너를 쓴 지 45일이 지나면 삭제").contains("이미 삭제됐을 수 있어요") + .contains("이력은 보존돼요").contains("문의 폼으로 알려 주세요").contains(FORM_URL); + assertThat(messageUtils.get(key + ".subject")).as(key).contains("비활성화됐어요").doesNotContain("{"); + } + } + + @Test + @DisplayName("홈 삭제 직전 안내: 계정 이름·남은 일수·삭제 안내일·다시 신청하는 방법이 들어간다") + void homeDeleteReminder() { + String body = messageUtils.get("notification.user.home-delete-reminder.body", NAME, "honggildong", "7", "2026-12-08"); + + assertWellFormed("home-delete-reminder", body); + assertThat(body).contains("/home/honggildong").contains("7일 뒤인 2026-12-08부터 삭제").contains("[GPU 신청]") + .contains("기존 홈 폴더를 그대로 사용"); + assertThat(messageUtils.get("notification.user.home-delete-reminder.subject", "1")) + .isEqualTo("[DGU AI LAB] 홈 폴더가 1일 뒤에 삭제돼요"); + } + + @Test + @DisplayName("NotificationMailer: 렌더링한 제목·본문을 그대로 한 통의 메일로 보낸다") + void mailerSendsRenderedBody() { + JavaMailSender sender = mock(JavaMailSender.class); + NotificationMailer mailer = new NotificationMailer(sender); + ReflectionTestUtils.setField(mailer, "from", "noreply@example.com"); + String subject = messageUtils.get("notification.user.home-delete-reminder.subject", "7"); + String body = messageUtils.get("notification.user.home-delete-reminder.body", NAME, "honggildong", "7", "2026-12-08"); + + assertThat(mailer.send("user@dgu.ac.kr", subject, body)).isTrue(); + + ArgumentCaptor sent = ArgumentCaptor.forClass(SimpleMailMessage.class); + verify(sender).send(sent.capture()); + assertThat(sent.getValue().getSubject()).isEqualTo(subject); + assertThat(sent.getValue().getText()).isEqualTo(body).isNotBlank(); + assertThat(sent.getValue().getTo()).containsExactly("user@dgu.ac.kr"); + } +} diff --git a/src/test/java/DGU_AI_LAB/admin_be/support/UserRegisterRequests.java b/src/test/java/DGU_AI_LAB/admin_be/support/UserRegisterRequests.java new file mode 100644 index 00000000..65461dc6 --- /dev/null +++ b/src/test/java/DGU_AI_LAB/admin_be/support/UserRegisterRequests.java @@ -0,0 +1,17 @@ +package DGU_AI_LAB.admin_be.support; + +import DGU_AI_LAB.admin_be.domain.users.dto.request.UserRegisterRequestDTO; + +import java.time.LocalDate; + +/** 졸업 예정일이 필수가 된 가입 요청을 졸업 예정일과 상관없는 테스트에서 간단히 만든다. */ +public final class UserRegisterRequests { + + private UserRegisterRequests() {} + + public static UserRegisterRequestDTO of(String email, String password, String name, String department, + String studentId, String phone, String ubuntuUsername, String contactEmail) { + return new UserRegisterRequestDTO(email, password, name, department, studentId, phone, ubuntuUsername, + contactEmail, LocalDate.now().plusYears(1)); + } +}