From 3d4270db023679ceb9b3ea273abe2b2de978c659 Mon Sep 17 00:00:00 2001 From: JalJu Date: Wed, 15 May 2024 00:28:58 +0900 Subject: [PATCH 1/7] =?UTF-8?q?Revert=20"[#70]=20cursor=20color=20?= =?UTF-8?q?=EC=B6=94=EA=B0=80=20(#71)"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 1372eb5383ae1d223a0e0360d57bed515be1cb72. --- .../out/liveblock/LiveblockApiAdapter.java | 46 ++----------------- .../adapter/out/openai/ChatGPTAdapter.java | 3 +- .../application/service/ProjectService.java | 5 +- 3 files changed, 7 insertions(+), 47 deletions(-) diff --git a/src/main/java/com/syncd/adapter/out/liveblock/LiveblockApiAdapter.java b/src/main/java/com/syncd/adapter/out/liveblock/LiveblockApiAdapter.java index 30ecd65..47f9cb9 100644 --- a/src/main/java/com/syncd/adapter/out/liveblock/LiveblockApiAdapter.java +++ b/src/main/java/com/syncd/adapter/out/liveblock/LiveblockApiAdapter.java @@ -13,7 +13,6 @@ import org.springframework.beans.factory.annotation.Value; import java.util.List; import java.util.Map; -import java.util.Random; import java.util.function.Function; import java.util.stream.Collectors; @@ -35,6 +34,7 @@ public LiveblocksTokenDto GetRoomAuthToken(String userId, String name,String img String jsonBody = createJsonBody(userId,name,img,projectIds); HttpEntity request = new HttpEntity<>(jsonBody, headers); +// System.out.print(request); return restTemplate.postForObject(url, request, LiveblocksTokenDto.class); } @@ -51,18 +51,18 @@ private String createJsonBody(String userId,String name, String img, List Epic = prompt(finalToken, om, requestTextForEpic); - String requestTextForUserstory = promptForUserStory.replace("{epics}", "\""+getMessage(Epic)+"\""); + + String requestTextForUserstory = promptForUserStory.replace("{epics}", getMessage(Epic)); Map userStory = prompt(finalToken, om, requestTextForUserstory); System.out.println(getMessage(userStory)); String res = extractJson(getMessage(userStory)); diff --git a/src/main/java/com/syncd/application/service/ProjectService.java b/src/main/java/com/syncd/application/service/ProjectService.java index c0ff94d..e7d4cc6 100644 --- a/src/main/java/com/syncd/application/service/ProjectService.java +++ b/src/main/java/com/syncd/application/service/ProjectService.java @@ -11,7 +11,6 @@ import com.syncd.domain.project.Project; import com.syncd.domain.project.UserInProject; import com.syncd.domain.user.User; -import com.syncd.dto.LiveblocksTokenDto; import com.syncd.dto.MakeUserStoryResponseDto; import com.syncd.dto.UserRoleDto; import com.syncd.enums.Role; @@ -89,9 +88,7 @@ public GetRoomAuthTokenResponseDto getRoomAuthToken(String userId) { .map(Project::getId) .collect(Collectors.toList()); User userInfo = readUserPort.findByUserId(userId); - String liveblocksTokenDto = liveblocksPort.GetRoomAuthToken(userId, userInfo.getName(), userInfo.getProfileImg(), projectIds).token(); - System.out.println(liveblocksTokenDto); - return new GetRoomAuthTokenResponseDto(liveblocksTokenDto); + return new GetRoomAuthTokenResponseDto(liveblocksPort.GetRoomAuthToken(userId, userInfo.getName(), userInfo.getProfileImg(), projectIds).token()); } @Override From 568c46be229c74159c7a8994b0094e9af96f7e48 Mon Sep 17 00:00:00 2001 From: JalJu Date: Sun, 19 May 2024 14:38:18 +0900 Subject: [PATCH 2/7] test: vaildation and mapper --- build.gradle | 2 + .../adapter/in/web/ProjectController.java | 5 +- .../syncd/adapter/in/web/RoomController.java | 1 - .../ProjectPersistenceAdapter.java | 11 +- .../persistence/UserPersistenceAdapter.java | 8 +- .../port/in/CreateProjectUsecase.java | 5 - .../port/in/DeleteProjectUsecase.java | 1 - .../port/in/MakeUserstoryUsecase.java | 8 +- .../port/in/SyncProjectUsecase.java | 8 +- .../port/in/UpdateProjectUsecase.java | 5 +- .../application/service/ProjectService.java | 15 +- .../syncd/domain/project/ProjectMapper.java | 25 -- .../com/syncd/domain/user/UserMapper.java | 25 -- .../syncd/dto/MakeUserStoryReauestDto.java | 7 +- src/main/java/com/syncd/dto/UserDto.java | 3 - .../java/com/syncd/dto/UserForTokenDto.java | 4 +- .../syncd/exceptions/ValidationMessages.java | 3 + .../java/com/syncd/mapper/ProjectMapper.java | 91 ++++++ .../java/com/syncd/mapper/UserMapper.java | 52 +++ .../adaptor/in/web/ProjectControllerTest.java | 304 ++++++++++++++++++ .../adaptor/in/web/RoomControllerTest.java | 66 ++++ .../adaptor/in/web/UserControllerTest.java | 63 ---- src/test/java/mapper/ProjectMapperTest.java | 151 +++++++++ src/test/java/mapper/UserMapperTest.java | 122 +++++++ 24 files changed, 832 insertions(+), 153 deletions(-) delete mode 100644 src/main/java/com/syncd/domain/project/ProjectMapper.java delete mode 100644 src/main/java/com/syncd/domain/user/UserMapper.java create mode 100644 src/main/java/com/syncd/mapper/ProjectMapper.java create mode 100644 src/main/java/com/syncd/mapper/UserMapper.java create mode 100644 src/test/java/adaptor/in/web/ProjectControllerTest.java create mode 100644 src/test/java/adaptor/in/web/RoomControllerTest.java delete mode 100644 src/test/java/adaptor/in/web/UserControllerTest.java create mode 100644 src/test/java/mapper/ProjectMapperTest.java create mode 100644 src/test/java/mapper/UserMapperTest.java diff --git a/build.gradle b/build.gradle index 5ccde2c..aa1eaa8 100644 --- a/build.gradle +++ b/build.gradle @@ -101,6 +101,8 @@ dependencies { //s3 implementation 'org.springframework.cloud:spring-cloud-starter-aws:2.2.6.RELEASE' + //validation + implementation 'org.springframework.boot:spring-boot-starter-validation' } test { diff --git a/src/main/java/com/syncd/adapter/in/web/ProjectController.java b/src/main/java/com/syncd/adapter/in/web/ProjectController.java index c1b478e..15acc25 100644 --- a/src/main/java/com/syncd/adapter/in/web/ProjectController.java +++ b/src/main/java/com/syncd/adapter/in/web/ProjectController.java @@ -23,6 +23,7 @@ @RequestMapping("/v1/project") public class ProjectController { private final GetAllRoomsByUserIdUsecase getAllRoomsByUserIdUsecase; + private final CreateProjectUsecase createProjectUsecase; private final JoinProjectUsecase joinProjectUsecase; @@ -36,11 +37,11 @@ public class ProjectController { private final UpdateProjectUsecase updateProjectUsecase; private final SyncProjectUsecase syncProjectUsecase; + private final MakeUserstoryUsecase makeUserstoryUsecase; private final JwtService jwtService; - @PostMapping(value = "/create") public CreateProjectResponseDto createProject(HttpServletRequest request, @Valid @ModelAttribute CreateProjectRequestDto requestDto) { String token = jwtService.resolveToken(request); @@ -84,7 +85,7 @@ public SyncProjectResponseDto syncProject(HttpServletRequest request, @Valid @Re } @PostMapping("/userstory") - public ResponseEntity makeUserStory(HttpServletRequest request, @RequestBody MakeUserStoryReauestDto makeUserStoryReauestDto) { + public ResponseEntity makeUserStory(HttpServletRequest request, @Valid @RequestBody MakeUserStoryReauestDto makeUserStoryReauestDto) { String token = jwtService.resolveToken(request); MakeUserStoryResponseDto result = makeUserstoryUsecase.makeUserstory(jwtService.getUserIdFromToken(token), makeUserStoryReauestDto.getProjectId(), makeUserStoryReauestDto.getScenario()); return new ResponseEntity<>(result, HttpStatus.OK); diff --git a/src/main/java/com/syncd/adapter/in/web/RoomController.java b/src/main/java/com/syncd/adapter/in/web/RoomController.java index 3901403..aae1b85 100644 --- a/src/main/java/com/syncd/adapter/in/web/RoomController.java +++ b/src/main/java/com/syncd/adapter/in/web/RoomController.java @@ -34,6 +34,5 @@ public GetAllRoomsByUserIdResponseDto getAllInfoAboutRoomsByUserId(HttpServletRe public GetRoomAuthTokenResponseDto getRoomAuthToken(@RequestBody @Valid GetRoomAuthTokenUsecase.TestDto getRoomAuthToken, HttpServletRequest request){ String token = jwtService.resolveToken(request); return getRoomAuthTokenUsecase.Test(jwtService.getUserIdFromToken(token),getRoomAuthToken.roomId()); - } } diff --git a/src/main/java/com/syncd/adapter/out/persistence/ProjectPersistenceAdapter.java b/src/main/java/com/syncd/adapter/out/persistence/ProjectPersistenceAdapter.java index f08eea9..d73062b 100644 --- a/src/main/java/com/syncd/adapter/out/persistence/ProjectPersistenceAdapter.java +++ b/src/main/java/com/syncd/adapter/out/persistence/ProjectPersistenceAdapter.java @@ -5,9 +5,9 @@ import com.syncd.application.port.out.persistence.project.ReadProjectPort; import com.syncd.application.port.out.persistence.project.WriteProjectPort; import com.syncd.domain.project.Project; -import com.syncd.domain.project.ProjectMapper; import com.syncd.exceptions.CustomException; import com.syncd.exceptions.ErrorInfo; +import com.syncd.mapper.ProjectMapper; import lombok.RequiredArgsConstructor; import org.springframework.stereotype.Repository; @@ -23,8 +23,9 @@ public class ProjectPersistenceAdapter implements WriteProjectPort, ReadProjectP @Override public List findAllProjectByUserId(String userId){ List projectEntityList = projectDao.findByUsersUserId(userId); + // List projects = ProjectMapper.INSTANCE.fromProjectEntities(projectEntityList); List projects = projectEntityList.stream() - .map(ProjectMapper.INSTANCE::fromProjectEntity) + .map(ProjectMapper.INSTANCE::mapProjectEntityToProject) .collect(Collectors.toList()); return projects; } @@ -32,7 +33,7 @@ public List findAllProjectByUserId(String userId){ @Override public Project findProjectByProjectId(String projectId){ return projectDao.findById(projectId) - .map(ProjectMapper.INSTANCE::fromProjectEntity) + .map(ProjectMapper.INSTANCE::mapProjectEntityToProject) .orElseThrow(() -> new CustomException(ErrorInfo.PROJECT_NOT_FOUND, "Project ID: " + projectId)); } @Override @@ -40,7 +41,7 @@ public String CreateProject(Project project) { if (project.getId() != null && projectDao.existsById(project.getId())) { throw new CustomException(ErrorInfo.PROJECT_ALREADY_EXISTS, "Project ID: " + project.getId()); } - ProjectEntity projectEntity = ProjectMapper.INSTANCE.toProjectEntity(project); + ProjectEntity projectEntity = ProjectMapper.INSTANCE.mapProjectToProjectEntity(project); ProjectEntity savedProjectEntity = projectDao.save(projectEntity); return savedProjectEntity.getId(); } @@ -58,7 +59,7 @@ public String UpdateProject(Project project) { if (project.getId() == null || !projectDao.existsById(project.getId())) { throw new CustomException(ErrorInfo.PROJECT_NOT_FOUND, "Project ID: " + project.getId()); } - ProjectEntity projectEntity = ProjectMapper.INSTANCE.toProjectEntity(project); + ProjectEntity projectEntity = ProjectMapper.INSTANCE.mapProjectToProjectEntity(project); ProjectEntity savedEntity = projectDao.save(projectEntity); return savedEntity.getId(); } diff --git a/src/main/java/com/syncd/adapter/out/persistence/UserPersistenceAdapter.java b/src/main/java/com/syncd/adapter/out/persistence/UserPersistenceAdapter.java index 5eba5a5..9c98b14 100644 --- a/src/main/java/com/syncd/adapter/out/persistence/UserPersistenceAdapter.java +++ b/src/main/java/com/syncd/adapter/out/persistence/UserPersistenceAdapter.java @@ -5,7 +5,7 @@ import com.syncd.application.port.out.persistence.user.ReadUserPort; import com.syncd.application.port.out.persistence.user.WriteUserPort; import com.syncd.domain.user.User; -import com.syncd.domain.user.UserMapper; +import com.syncd.mapper.UserMapper; import com.syncd.dto.UserId; import com.syncd.enums.UserAccountStatus; import com.syncd.exceptions.CustomException; @@ -60,21 +60,21 @@ public UserId updateUser(User user) { @Override public User findByEmail(String email) { return userDao.findByEmail(email) - .map(UserMapper.INSTANCE::fromEntity) + .map(UserMapper.INSTANCE::mapUserEntityToUser) .orElseThrow(() -> new CustomException(ErrorInfo.USER_NOT_FOUND, "User Email: " + email)); } @Override public User findByUsername(String username) { return userDao.findByName(username) - .map(UserMapper.INSTANCE::fromEntity) + .map(UserMapper.INSTANCE::mapUserEntityToUser) .orElseThrow(() -> new CustomException(ErrorInfo.USER_NOT_FOUND, "User Name: " + username)); } @Override public User findByUserId(String userId) { return userDao.findById(userId) - .map(UserMapper.INSTANCE::fromEntity) + .map(UserMapper.INSTANCE::mapUserEntityToUser) .orElseThrow(() -> new CustomException(ErrorInfo.USER_NOT_FOUND, "User ID: " + userId)); } diff --git a/src/main/java/com/syncd/application/port/in/CreateProjectUsecase.java b/src/main/java/com/syncd/application/port/in/CreateProjectUsecase.java index 1305534..9dbde74 100644 --- a/src/main/java/com/syncd/application/port/in/CreateProjectUsecase.java +++ b/src/main/java/com/syncd/application/port/in/CreateProjectUsecase.java @@ -2,8 +2,6 @@ import com.syncd.exceptions.ValidationMessages; import jakarta.validation.constraints.NotBlank; -import jakarta.validation.constraints.NotNull; -import jakarta.validation.constraints.Size; import org.springframework.web.multipart.MultipartFile; import java.util.List; @@ -20,11 +18,8 @@ public interface CreateProjectUsecase { record CreateProjectRequestDto( @NotBlank(message = ValidationMessages.NAME_NOT_BLANK) String name, - @NotBlank(message = ValidationMessages.DESCRIPTION_NOT_BLANK) String description, MultipartFile img, - @NotNull(message = ValidationMessages.USERS_NOT_NULL) - @Size(min = 1, message = ValidationMessages.USERS_SIZE) List userEmails ) { } diff --git a/src/main/java/com/syncd/application/port/in/DeleteProjectUsecase.java b/src/main/java/com/syncd/application/port/in/DeleteProjectUsecase.java index 9d3627f..fb08702 100644 --- a/src/main/java/com/syncd/application/port/in/DeleteProjectUsecase.java +++ b/src/main/java/com/syncd/application/port/in/DeleteProjectUsecase.java @@ -13,7 +13,6 @@ public interface DeleteProjectUsecase { // DTO // ====================================== record DeleteProjectResponseDto( - String projectId ){ diff --git a/src/main/java/com/syncd/application/port/in/MakeUserstoryUsecase.java b/src/main/java/com/syncd/application/port/in/MakeUserstoryUsecase.java index ca03b54..89e9674 100644 --- a/src/main/java/com/syncd/application/port/in/MakeUserstoryUsecase.java +++ b/src/main/java/com/syncd/application/port/in/MakeUserstoryUsecase.java @@ -1,10 +1,16 @@ package com.syncd.application.port.in; import com.syncd.dto.MakeUserStoryResponseDto; +import com.syncd.exceptions.ValidationMessages; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotEmpty; +import jakarta.validation.constraints.NotNull; import lombok.Data; import java.util.List; public interface MakeUserstoryUsecase { - MakeUserStoryResponseDto makeUserstory(String userId, String projectId, List scenarios); + MakeUserStoryResponseDto makeUserstory(String userId, + String projectId, + List scenarios); } diff --git a/src/main/java/com/syncd/application/port/in/SyncProjectUsecase.java b/src/main/java/com/syncd/application/port/in/SyncProjectUsecase.java index 8629604..6c09d24 100644 --- a/src/main/java/com/syncd/application/port/in/SyncProjectUsecase.java +++ b/src/main/java/com/syncd/application/port/in/SyncProjectUsecase.java @@ -1,5 +1,9 @@ package com.syncd.application.port.in; +import com.syncd.exceptions.ValidationMessages; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + public interface SyncProjectUsecase { // ====================================== // METHOD @@ -10,8 +14,10 @@ public interface SyncProjectUsecase { // ====================================== record SyncProjectRequestDto( + @NotBlank(message = ValidationMessages.PROJECT_ID_NOT_BLANK) String projectId, - int projectStage + @NotNull(message = ValidationMessages.PROJECT_PROGRESS_NOT_NULL) + Integer projectStage ){} record SyncProjectResponseDto( diff --git a/src/main/java/com/syncd/application/port/in/UpdateProjectUsecase.java b/src/main/java/com/syncd/application/port/in/UpdateProjectUsecase.java index 8062ca1..b077ea4 100644 --- a/src/main/java/com/syncd/application/port/in/UpdateProjectUsecase.java +++ b/src/main/java/com/syncd/application/port/in/UpdateProjectUsecase.java @@ -7,7 +7,7 @@ public interface UpdateProjectUsecase { // ====================================== // METHOD // ====================================== - UpdateProjectResponseDto updateProject(String userId, String projectId, + UpdateProjectResponseDto updateProject(String userId, String projectId, String projectName, String description, String image ); @@ -18,12 +18,9 @@ UpdateProjectResponseDto updateProject(String userId, String projectId, record UpdateProjectRequestDto( @NotBlank(message = ValidationMessages.PROJECT_ID_NOT_BLANK) String projectId, - @NotBlank(message = ValidationMessages.PROJECT_NAME_NOT_BLANK) String projectName, - @NotBlank(message = ValidationMessages.DESCRIPTION_NOT_BLANK) String description, String image - ) { } diff --git a/src/main/java/com/syncd/application/service/ProjectService.java b/src/main/java/com/syncd/application/service/ProjectService.java index e7d4cc6..095d72d 100644 --- a/src/main/java/com/syncd/application/service/ProjectService.java +++ b/src/main/java/com/syncd/application/service/ProjectService.java @@ -15,19 +15,16 @@ import com.syncd.dto.UserRoleDto; import com.syncd.enums.Role; import com.syncd.exceptions.*; +import com.syncd.mapper.ProjectMapper; import lombok.RequiredArgsConstructor; import org.springframework.context.annotation.Primary; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.web.multipart.MultipartFile; - -import java.io.IOException; -import java.time.LocalDateTime; -import java.util.ArrayList; import java.util.List; import java.util.Optional; import java.util.stream.Collectors; -import java.util.stream.Stream; + @Service @@ -42,6 +39,7 @@ public class ProjectService implements CreateProjectUsecase, GetAllRoomsByUserId private final SendMailPort sendMailPort; private final ChatGPTPort chatGPTPort; private final S3Port s3Port; + private final ProjectMapper projectMappers; @Override public CreateProjectResponseDto createProject(String hostId, String hostName, String projectName, String description, MultipartFile img, List userEmails){ @@ -76,7 +74,7 @@ public JoinProjectUsecase.JoinProjectResponseDto joinProject(String userId, Stri @Override public GetAllRoomsByUserIdResponseDto getAllRoomsByUserId(String userId) { List projects = readProjectPort.findAllProjectByUserId(userId); - GetAllRoomsByUserIdResponseDto responseDto = mapProjectsToResponse(userId, projects); + GetAllRoomsByUserIdResponseDto responseDto = mapProjectsToResponse(userId, projects); return responseDto; } @@ -84,6 +82,7 @@ public GetAllRoomsByUserIdResponseDto getAllRoomsByUserId(String userId) { @Override public GetRoomAuthTokenResponseDto getRoomAuthToken(String userId) { List projects = readProjectPort.findAllProjectByUserId(userId); +// List projectIds = projectMappers.mapProjectToProjectId(projects); List projectIds = projects.stream() .map(Project::getId) .collect(Collectors.toList()); @@ -101,7 +100,6 @@ public DeleteProjectResponseDto deleteProject(String userId, String projectId) { Project project = readProjectPort.findProjectByProjectId(projectId); if (project == null) { throw new CustomException(ErrorInfo.PROJECT_NOT_FOUND, "Project ID: " + projectId); - // ... 코드 생략 ... } String imgFileName = project.getImgFileName(); @@ -121,11 +119,11 @@ public InviteUserInProjectResponseDto inviteUserInProject(String userId, String checkHost(project, userId); User host = readUserPort.findByUserId(userId); + // List users = projectMappers.mapEmailsToUsersInProject(userEmails, host.getName(), project.getName(), projectId, readUserPort, sendMailPort); List users = userEmails.stream() .map(email -> createUserInProjectWithRoleMember(email, host.getName(), project.getName(), projectId)) .collect(Collectors.toList()); - return new InviteUserInProjectResponseDto(projectId); } @@ -237,5 +235,4 @@ private ProjectForGetAllInfoAboutRoomsByUserIdResponseDto convertProjectToDto(St private UserRoleDto convertUserToUserRoleDto(String projectId, UserInProject user) { return new UserRoleDto(projectId, user.getUserId(), user.getRole()); } - } diff --git a/src/main/java/com/syncd/domain/project/ProjectMapper.java b/src/main/java/com/syncd/domain/project/ProjectMapper.java deleted file mode 100644 index 87dc043..0000000 --- a/src/main/java/com/syncd/domain/project/ProjectMapper.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.syncd.domain.project; - - -import com.syncd.adapter.out.persistence.repository.project.ProjectEntity; -import com.syncd.application.port.in.CreateProjectUsecase; -import com.syncd.application.port.in.GetAllRoomsByUserIdUsecase; -import org.mapstruct.Mapper; -import org.mapstruct.Mapping; -import org.mapstruct.Mappings; -import org.mapstruct.Named; -import org.mapstruct.factory.Mappers; - -import java.util.List; -import java.util.stream.Collectors; - -@Mapper(componentModel = "spring") -public interface ProjectMapper { - ProjectMapper INSTANCE = Mappers.getMapper(ProjectMapper.class); - Project fromProjectEntity(ProjectEntity projectEntity); - - ProjectEntity toProjectEntity(Project project); - -} - - diff --git a/src/main/java/com/syncd/domain/user/UserMapper.java b/src/main/java/com/syncd/domain/user/UserMapper.java deleted file mode 100644 index 4c1fd50..0000000 --- a/src/main/java/com/syncd/domain/user/UserMapper.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.syncd.domain.user; - - -import com.syncd.adapter.out.persistence.repository.user.UserEntity; -import com.syncd.application.port.in.RegitsterUserUsecase; -import com.syncd.dto.UserDto; -import com.syncd.dto.UserForTokenDto; -import com.syncd.dto.UserRoleDto; -import org.mapstruct.Mapper; -import org.mapstruct.factory.Mappers; - - -@Mapper -public interface UserMapper { - UserMapper INSTANCE = Mappers.getMapper(UserMapper.class); - - User fromRegisterUserRequestDto(RegitsterUserUsecase.RegisterUserRequestDto requestDto); - UserForTokenDto toUserForTokenDto(User user); - - User fromEntity(UserEntity userEntity); - - User fromDto(UserDto dto); - - UserRoleDto toUserRoleForTeamDto(User user); -} diff --git a/src/main/java/com/syncd/dto/MakeUserStoryReauestDto.java b/src/main/java/com/syncd/dto/MakeUserStoryReauestDto.java index f9c3d84..5831dc3 100644 --- a/src/main/java/com/syncd/dto/MakeUserStoryReauestDto.java +++ b/src/main/java/com/syncd/dto/MakeUserStoryReauestDto.java @@ -1,12 +1,17 @@ package com.syncd.dto; +import com.syncd.exceptions.ValidationMessages; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotEmpty; +import jakarta.validation.constraints.NotNull; import lombok.Data; import java.util.List; @Data public class MakeUserStoryReauestDto { + @NotBlank(message = ValidationMessages.PROJECT_ID_NOT_BLANK) private String projectId; + @NotNull(message = ValidationMessages.SCENARIOS_NOT_NULL) @NotEmpty(message = ValidationMessages.SCENARIOS_NOT_EMPTY) private List scenario; - } \ No newline at end of file diff --git a/src/main/java/com/syncd/dto/UserDto.java b/src/main/java/com/syncd/dto/UserDto.java index a35d0e1..b90ee18 100644 --- a/src/main/java/com/syncd/dto/UserDto.java +++ b/src/main/java/com/syncd/dto/UserDto.java @@ -1,12 +1,9 @@ package com.syncd.dto; - import com.syncd.enums.UserAccountStatus; -import lombok.Data; import java.util.List; public record UserDto( - String id, String email, String name, diff --git a/src/main/java/com/syncd/dto/UserForTokenDto.java b/src/main/java/com/syncd/dto/UserForTokenDto.java index f797e2e..f856e01 100644 --- a/src/main/java/com/syncd/dto/UserForTokenDto.java +++ b/src/main/java/com/syncd/dto/UserForTokenDto.java @@ -1,6 +1,4 @@ -package com.syncd.dto; - -import lombok.Data; +package com.syncd.dto;; public record UserForTokenDto( String userId diff --git a/src/main/java/com/syncd/exceptions/ValidationMessages.java b/src/main/java/com/syncd/exceptions/ValidationMessages.java index 6baccf7..593df90 100644 --- a/src/main/java/com/syncd/exceptions/ValidationMessages.java +++ b/src/main/java/com/syncd/exceptions/ValidationMessages.java @@ -9,4 +9,7 @@ public class ValidationMessages { public static final String PROJECT_NAME_NOT_BLANK = "Project Name must not be blank"; public static final String USER_ID_NOT_BLANK = "User ID cannot be blank"; public static final String ROOM_ID_NOT_BLANK = "ROOM ID cannot be blank"; + public static final String PROJECT_PROGRESS_NOT_NULL = "Project progress must not be null"; + public static final String SCENARIOS_NOT_NULL = "Scenarios cannot be null"; + public static final String SCENARIOS_NOT_EMPTY = "Scenarios cannot be empty"; } diff --git a/src/main/java/com/syncd/mapper/ProjectMapper.java b/src/main/java/com/syncd/mapper/ProjectMapper.java new file mode 100644 index 0000000..bee4ea7 --- /dev/null +++ b/src/main/java/com/syncd/mapper/ProjectMapper.java @@ -0,0 +1,91 @@ +package com.syncd.mapper; + +import com.syncd.adapter.out.persistence.repository.project.ProjectEntity; +import com.syncd.application.port.in.GetAllRoomsByUserIdUsecase.*; +import com.syncd.application.port.out.gmail.SendMailPort; +import com.syncd.application.port.out.persistence.user.ReadUserPort; +import com.syncd.domain.project.Project; +import com.syncd.domain.project.UserInProject; +import com.syncd.domain.user.User; +import com.syncd.enums.Role; +import org.mapstruct.Mapper; +import org.mapstruct.factory.Mappers; + +import java.util.List; +import java.util.stream.Collectors; + +@Mapper(componentModel = "spring") +public interface ProjectMapper { + ProjectMapper INSTANCE = Mappers.getMapper(ProjectMapper.class); + + Project mapProjectEntityToProject(ProjectEntity projectEntity); + + ProjectEntity mapProjectToProjectEntity(Project project); + + List mapProjectEntitiesToProjects(List projectEntities); + + ProjectForGetAllInfoAboutRoomsByUserIdResponseDto mapProjectToProjectForGetAllInfoDto(Project project); + + default String mapProjectToProjectId(Project project) { + return project.getId(); + } + + default List mapProjectsToProjectIds(List projects) { + return projects.stream() + .map(this::mapProjectToProjectId) + .collect(Collectors.toList()); + } + + default List mapProjectsToProjectForGetAllInfoDtos(String userId, List projects) { + return projects.stream() + .map(project -> convertProjectToProjectForGetAllInfoDto(userId, project)) + .filter(dto -> dto != null) + .collect(Collectors.toList()); + } + + default ProjectForGetAllInfoAboutRoomsByUserIdResponseDto convertProjectToProjectForGetAllInfoDto(String userId, Project project) { + Role role = determineUserRole(project.getUsers(), userId); + List userEmails = extractUserEmails(project.getUsers()); + + return new ProjectForGetAllInfoAboutRoomsByUserIdResponseDto( + project.getName(), + project.getId(), + project.getDescription(), + role, + userEmails, + project.getProgress(), + project.getLastModifiedDate() + ); + } + + default Role determineUserRole(List users, String userId) { + return users.stream() + .filter(user -> user.getUserId().equals(userId)) + .map(UserInProject::getRole) + .findFirst() + .orElse(Role.MEMBER); + } + + default List extractUserEmails(List users) { + return users.stream() + .map(UserInProject::getUserId) + .collect(Collectors.toList()); + } + + default GetAllRoomsByUserIdResponseDto mapProjectsToGetAllRoomsByUserIdResponseDto(String userId, List projects) { + List projectDtos = mapProjectsToProjectForGetAllInfoDtos(userId, projects); + return new GetAllRoomsByUserIdResponseDto(userId, projectDtos); + } + + default List mapEmailsToUsersInProject(List userEmails, String hostName, String projectName, String projectId, ReadUserPort readUserPort, SendMailPort sendMailPort) { + return userEmails.stream() + .map(email -> createUserInProjectWithRoleMember(email, hostName, projectName, projectId, readUserPort, sendMailPort)) + .collect(Collectors.toList()); + } + + default UserInProject createUserInProjectWithRoleMember(String userEmail, String hostName, String projectName, String projectId, ReadUserPort readUserPort, SendMailPort sendMailPort) { + User user = readUserPort.findByEmail(userEmail); + sendMailPort.sendInviteMail(userEmail, hostName, user.getName(), projectName, projectId); + return new UserInProject(user.getId(), Role.MEMBER); + } +} diff --git a/src/main/java/com/syncd/mapper/UserMapper.java b/src/main/java/com/syncd/mapper/UserMapper.java new file mode 100644 index 0000000..34fb2d8 --- /dev/null +++ b/src/main/java/com/syncd/mapper/UserMapper.java @@ -0,0 +1,52 @@ +package com.syncd.mapper; + + +import com.syncd.adapter.out.persistence.repository.user.UserEntity; +import com.syncd.application.port.in.RegitsterUserUsecase; +import com.syncd.domain.project.UserInProject; +import com.syncd.domain.user.User; +import com.syncd.dto.UserDto; +import com.syncd.dto.UserForTokenDto; +import com.syncd.dto.UserRoleDto; +import com.syncd.enums.Role; +import org.mapstruct.AfterMapping; +import org.mapstruct.Mapper; +import org.mapstruct.Mapping; +import org.mapstruct.MappingTarget; +import org.mapstruct.factory.Mappers; + +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; + + +@Mapper +public interface UserMapper { + UserMapper INSTANCE = Mappers.getMapper(UserMapper.class); + + @Mapping(target = "id", ignore = true) + @Mapping(target = "profileImg", ignore = true) + User mapRegisterUserRequestDtoToUser(RegitsterUserUsecase.RegisterUserRequestDto requestDto); + + @Mapping(source = "id", target = "userId") + UserForTokenDto mapUserToUserForTokenDto(User user); + + User mapUserEntityToUser(UserEntity userEntity); + + User mapUserDtoToUser(UserDto dto); + + @Mapping(target = "projectIds", ignore = true) + UserDto mapUserToUserDto(User user); + + default UserRoleDto mapUserToUserRoleDto(User user, String projectId, Role role) { + return new UserRoleDto(projectId, user.getId(), role); + } + default List mapEmailsToUserInProjectList(List userEmails, String hostName, String projectName, String projectId) { + return userEmails.stream() + .map(email -> createUserInProjectWithRoleMember(email, hostName, projectName, projectId)) + .collect(Collectors.toList()); + } + default UserInProject createUserInProjectWithRoleMember(String email, String hostName, String projectName, String projectId) { + return new UserInProject(email, Role.MEMBER); + } +} diff --git a/src/test/java/adaptor/in/web/ProjectControllerTest.java b/src/test/java/adaptor/in/web/ProjectControllerTest.java new file mode 100644 index 0000000..3103d75 --- /dev/null +++ b/src/test/java/adaptor/in/web/ProjectControllerTest.java @@ -0,0 +1,304 @@ +package adaptor.in.web; + +import com.syncd.application.port.in.CreateProjectUsecase.*; +import com.syncd.application.port.in.DeleteProjectUsecase.*; +import com.syncd.application.port.in.InviteUserInProjectUsecase.*; +import com.syncd.application.port.in.JoinProjectUsecase.*; +import com.syncd.application.port.in.SyncProjectUsecase.*; +import com.syncd.application.port.in.UpdateProjectUsecase.*; +import com.syncd.application.port.in.WithdrawUserInProjectUsecase.*; +import com.syncd.dto.MakeUserStoryReauestDto; +import com.syncd.exceptions.ValidationMessages; +import jakarta.validation.ConstraintViolation; +import jakarta.validation.Validation; +import jakarta.validation.Validator; +import jakarta.validation.ValidatorFactory; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; + +public class ProjectControllerTest { + + private Validator validator; + + @BeforeEach + void setUp() { + ValidatorFactory factory = Validation.buildDefaultValidatorFactory(); + validator = factory.getValidator(); + } + + @Test + @DisplayName("Create Project - Invalid Request - Blank Project Name") + void testCreateProject_InvalidRequest_BlankName() { + CreateProjectRequestDto requestDto = new CreateProjectRequestDto("", "description", null, Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.NAME_NOT_BLANK); + } + + @Test + @DisplayName("Create Project - Valid Request - Only Project Name Provided") + void testCreateProject_ValidRequest_OnlyName() { + CreateProjectRequestDto requestDto = new CreateProjectRequestDto("Valid Project", "", null, Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + @Test + @DisplayName("Join Project - Invalid Request - Blank ProjectId") + void testJoinProject_InvalidRequest_BlankProjectId() { + JoinProjectRequestDto requestDto = new JoinProjectRequestDto(""); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Join Project - Valid Request") + void testJoinProject_ValidRequest() { + JoinProjectRequestDto requestDto = new JoinProjectRequestDto("validProjectId"); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + @Test + @DisplayName("Invite User - Invalid Request - Blank ProjectId and Empty Users") + void testInviteUser_InvalidRequest_BlankProjectIdAndEmptyUsers() { + InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(2); + + List messages = violations.stream() + .map(ConstraintViolation::getMessage) + .toList(); + + assertThat(messages).contains( + ValidationMessages.PROJECT_ID_NOT_BLANK, + ValidationMessages.USERS_SIZE + ); + } + + @Test + @DisplayName("Invite User - Invalid Request - Blank ProjectId") + void testInviteUser_InvalidRequest_BlankProjectId() { + InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("", List.of("user1@example.com")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Invite User - Invalid Request - Empty Users") + void testInviteUser_InvalidRequest_EmptyUsers() { + InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("validProjectId", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); + } + + @Test + @DisplayName("Invite User - Invalid Request - Less Than 1 User") + void testInviteUser_InvalidRequest_LessThanOneUser() { + InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("validProjectId", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); + } + + @Test + @DisplayName("Invite User - Valid Request") + void testInviteUser_ValidRequest() { + InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("validProjectId", List.of("user1@example.com")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + @Test + @DisplayName("Withdraw User - Invalid Request - Blank ProjectId and Empty Users") + void testWithdrawUser_InvalidRequest_BlankProjectIdAndEmptyUsers() { + WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(2); + + List messages = violations.stream() + .map(ConstraintViolation::getMessage) + .toList(); + + assertThat(messages).contains( + ValidationMessages.PROJECT_ID_NOT_BLANK + ); + } + + @Test + @DisplayName("Withdraw User - Invalid Request - Blank ProjectId") + void testWithdrawUser_InvalidRequest_BlankProjectId() { + WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("", List.of("user1@example.com")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Withdraw User - Invalid Request - Empty Users") + void testWithdrawUser_InvalidRequest_EmptyUsers() { + WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("validProjectId", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); + } + + @Test + @DisplayName("Withdraw User - Invalid Request - Less Than 1 User") + void testWithdrawUser_InvalidRequest_LessThanOneUser() { + WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("validProjectId", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); + } + + @Test + @DisplayName("Withdraw User - Valid Request") + void testWithdrawUser_ValidRequest() { + WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("validProjectId", List.of("user1@example.com")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + @Test + @DisplayName("Delete Project - Invalid Request - Blank ProjectId") + void testDeleteProject_InvalidRequest_BlankProjectId() { + DeleteProjectRequestDto requestDto = new DeleteProjectRequestDto(""); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Delete Project - Valid Request") + void testDeleteProject_ValidRequest() { + DeleteProjectRequestDto requestDto = new DeleteProjectRequestDto("validProjectId"); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + @Test + @DisplayName("Update Project - Invalid Request - Blank ProjectId") + void testUpdateProject_InvalidRequest_BlankProjectId() { + UpdateProjectRequestDto requestDto = new UpdateProjectRequestDto("", "name", "desc", null); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Update Project - Valid Request") + void testUpdateProject_ValidRequest() { + UpdateProjectRequestDto requestDto = new UpdateProjectRequestDto("validProjectId", "newName", "newDesc", null); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + @Test + @DisplayName("Sync Project - Invalid Request - Blank ProjectId") + void testSyncProject_InvalidRequest_BlankProjectId() { + SyncProjectRequestDto requestDto = new SyncProjectRequestDto("", 10); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Sync Project - Invalid Request - Null Project Stage") + void testSyncProject_InvalidRequest_NullProjectStage() { + SyncProjectRequestDto requestDto = new SyncProjectRequestDto("validProjectId", null); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_PROGRESS_NOT_NULL); + } + + @Test + @DisplayName("Sync Project - Valid Request") + void testSyncProject_ValidRequest() { + SyncProjectRequestDto requestDto = new SyncProjectRequestDto("validProjectId", 10); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + @Test + @DisplayName("Make User Story - Invalid Request - Blank ProjectId") + void testMakeUserStory_InvalidRequest_BlankProjectId() { + MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); + requestDto.setProjectId(""); + requestDto.setScenario(List.of("Scenario 1")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Make User Story - Invalid Request - Null Scenarios") + void testMakeUserStory_InvalidRequest_NullScenarios() { + MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); + requestDto.setProjectId("projectId"); + requestDto.setScenario(null); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(2); + List messages = violations.stream() + .map(ConstraintViolation::getMessage) + .toList(); + assertThat(messages).contains( + ValidationMessages.SCENARIOS_NOT_NULL, + ValidationMessages.SCENARIOS_NOT_EMPTY + ); + } + + @Test + @DisplayName("Make User Story - Invalid Request - Empty Scenarios") + void testMakeUserStory_InvalidRequest_EmptyScenarios() { + MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); + requestDto.setProjectId("projectId"); + requestDto.setScenario(Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.SCENARIOS_NOT_EMPTY); + } + + @Test + @DisplayName("Make User Story - Valid Request") + void testMakeUserStory_ValidRequest() { + MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); + requestDto.setProjectId("validProjectId"); + requestDto.setScenario(List.of("Scenario 1")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } +} \ No newline at end of file diff --git a/src/test/java/adaptor/in/web/RoomControllerTest.java b/src/test/java/adaptor/in/web/RoomControllerTest.java new file mode 100644 index 0000000..07698e3 --- /dev/null +++ b/src/test/java/adaptor/in/web/RoomControllerTest.java @@ -0,0 +1,66 @@ +package adaptor.in.web; + +import com.syncd.application.port.in.GetAllRoomsByUserIdUsecase.*; +import com.syncd.application.port.in.GetRoomAuthTokenUsecase.*; +import com.syncd.exceptions.ValidationMessages; +import jakarta.validation.Validation; +import jakarta.validation.Validator; +import jakarta.validation.ConstraintViolation; +import jakarta.validation.ValidatorFactory; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.Set; + +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; + +public class RoomControllerTest { + private Validator validator; + + @BeforeEach + void setUp(){ + ValidatorFactory factory = Validation.buildDefaultValidatorFactory(); + validator = factory.getValidator(); + } + + @Test + @DisplayName("Get Room Auth Token - Invalid Request - Blank RoomId") + void testGetRoomAuthToken_InvalidRequest_BlankRoomId() { + TestDto requestDto = new TestDto(""); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.ROOM_ID_NOT_BLANK); + } + + @Test + @DisplayName("Get Room Auth Token - Valid Request") + void testGetRoomAuthToken_ValidRequest() { + TestDto requestDto = new TestDto("validRoomId"); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + + @Test + @DisplayName("Get All Rooms By User Id - Invalid Request - Blank UserId") + void testGetAllRoomsByUserId_InvalidRequest_BlankUserId() { + GetAllRoomsByUserIdRequestDto requestDto = new GetAllRoomsByUserIdRequestDto(""); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USER_ID_NOT_BLANK); + } + + @Test + @DisplayName("Get All Rooms By User Id - Valid Request") + void testGetAllRoomsByUserId_ValidRequest() { + GetAllRoomsByUserIdRequestDto requestDto = new GetAllRoomsByUserIdRequestDto("validUserId"); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + +} diff --git a/src/test/java/adaptor/in/web/UserControllerTest.java b/src/test/java/adaptor/in/web/UserControllerTest.java deleted file mode 100644 index 383431e..0000000 --- a/src/test/java/adaptor/in/web/UserControllerTest.java +++ /dev/null @@ -1,63 +0,0 @@ -package adaptor.in.web; - -import com.syncd.application.service.JwtService; -import com.syncd.adapter.in.web.UserController; -import com.syncd.application.port.in.GetUserInfoUsecase; -import jakarta.servlet.http.HttpServletRequest; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; - -import static org.junit.jupiter.api.Assertions.*; -import static org.mockito.Mockito.*; - -class MockGetUserInfoUsecase implements GetUserInfoUsecase{ - - @Override - public GetUserInfoResponseDto getUserInfo(String userId) { - return null; - } -} - -class UserControllerTest { - - private UserController userController; - - private GetUserInfoUsecase getUserInfoUsecase = new MockGetUserInfoUsecase(); - - @Mock - private JwtService jwtService; - - @Mock - private HttpServletRequest request; - - @BeforeEach - void setUp() { - MockitoAnnotations.initMocks(this); - userController = new UserController(getUserInfoUsecase, jwtService); - } - - @Test - void getUserInfo_ReturnsUserInfo_WhenValidTokenProvided() { - // Arrange - String token = "valid_token"; - String userId = "user123"; - when(jwtService.resolveToken(request)).thenReturn(token); - when(jwtService.getUserIdFromToken(token)).thenReturn(userId); - - GetUserInfoUsecase.GetUserInfoResponseDto expectedUserInfo = new GetUserInfoUsecase.GetUserInfoResponseDto(null,null,null,null,null); - // Assuming you have some mock data or create an instance here - - when(getUserInfoUsecase.getUserInfo(userId)).thenReturn(expectedUserInfo); - - // Act - GetUserInfoUsecase.GetUserInfoResponseDto actualUserInfo = userController.getUserInfo(request); - - // Assert - assertEquals(expectedUserInfo, actualUserInfo); - verify(jwtService).resolveToken(request); - verify(jwtService).getUserIdFromToken(token); - verify(getUserInfoUsecase).getUserInfo(userId); - } -} \ No newline at end of file diff --git a/src/test/java/mapper/ProjectMapperTest.java b/src/test/java/mapper/ProjectMapperTest.java new file mode 100644 index 0000000..9427d4e --- /dev/null +++ b/src/test/java/mapper/ProjectMapperTest.java @@ -0,0 +1,151 @@ +package mapper; + +import com.syncd.adapter.out.persistence.repository.project.ProjectEntity; +import com.syncd.application.port.in.GetAllRoomsByUserIdUsecase.*; +import com.syncd.domain.project.Project; +import com.syncd.domain.project.UserInProject; +import com.syncd.enums.Role; +import com.syncd.mapper.ProjectMapper; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mapstruct.factory.Mappers; + +import java.util.Arrays; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +public class ProjectMapperTest { + private final ProjectMapper projectMapper = Mappers.getMapper(ProjectMapper.class); + private ProjectEntity entity1; + private Project project1; + private UserInProject user1; + private UserInProject user2; + + @BeforeEach + void setUp() { + entity1 = new ProjectEntity(); + entity1.setId("id1"); + entity1.setName("Project 1"); + + user1 = new UserInProject("user1@example.com", Role.MEMBER); + user2 = new UserInProject("user2@example.com", Role.HOST); + + project1 = new Project(); + project1.setId("id1"); + project1.setName("Project 1"); + project1.setDescription("Description 1"); + project1.setUsers(Arrays.asList(user1, user2)); + project1.setProgress(50); + project1.setLastModifiedDate("2022-01-01"); + } + + @Test + public void testMapProjectEntitiesToProjects() { + ProjectEntity entity2 = new ProjectEntity(); + entity2.setId("id2"); + entity2.setName("Project 2"); + + List entities = Arrays.asList(entity1, entity2); + + List projects = projectMapper.mapProjectEntitiesToProjects(entities); + + assertNotNull(projects); + assertEquals(2, projects.size()); + + assertEquals("id1", projects.get(0).getId()); + assertEquals("Project 1", projects.get(0).getName()); + assertEquals("id2", projects.get(1).getId()); + assertEquals("Project 2", projects.get(1).getName()); + } + + @Test + public void testMapProjectsToProjectIds() { + Project project2 = new Project(); + project2.setId("id2"); + project2.setName("Project 2"); + + List projects = Arrays.asList(project1, project2); + + List projectIds = projectMapper.mapProjectsToProjectIds(projects); + + assertNotNull(projectIds); + assertEquals(2, projectIds.size()); + assertTrue(projectIds.contains("id1")); + assertTrue(projectIds.contains("id2")); + } + + @Test + public void testFromProjectEntity() { + Project project = projectMapper.mapProjectEntityToProject(entity1); + + assertNotNull(project); + assertEquals("id1", project.getId()); + assertEquals("Project 1", project.getName()); + } + + @Test + public void testToProjectEntity() { + ProjectEntity entity = projectMapper.mapProjectToProjectEntity(project1); + + assertNotNull(entity); + assertEquals("id1", entity.getId()); + assertEquals("Project 1", entity.getName()); + } + + @Test + public void testConvertProjectToDto() { + ProjectForGetAllInfoAboutRoomsByUserIdResponseDto dto = projectMapper.convertProjectToProjectForGetAllInfoDto("user1@example.com", project1); + + assertNotNull(dto); + assertEquals("id1", dto.id()); + assertEquals("Project 1", dto.name()); + assertEquals("Description 1", dto.description()); + assertEquals(Role.MEMBER, dto.role()); + assertEquals(2, dto.userEmails().size()); + assertTrue(dto.userEmails().contains("user1@example.com")); + assertTrue(dto.userEmails().contains("user2@example.com")); + assertEquals(50, dto.progress()); + assertEquals("2022-01-01", dto.lastModifiedDate()); + } + + @Test + public void testMapProjectsToResponse() { + Project project2 = new Project(); + project2.setId("id2"); + project2.setName("Project 2"); + project2.setDescription("Description 2"); + project2.setUsers(Arrays.asList(user1)); + project2.setProgress(70); + project2.setLastModifiedDate("2022-02-01"); + + List projects = Arrays.asList(project1, project2); + + GetAllRoomsByUserIdResponseDto responseDto = projectMapper.mapProjectsToGetAllRoomsByUserIdResponseDto("user1@example.com", projects); + + assertNotNull(responseDto); + assertEquals("user1@example.com", responseDto.userId()); + assertEquals(2, responseDto.projects().size()); + + ProjectForGetAllInfoAboutRoomsByUserIdResponseDto dto1 = responseDto.projects().get(0); + assertEquals("id1", dto1.id()); + assertEquals("Project 1", dto1.name()); + assertEquals("Description 1", dto1.description()); + assertEquals(Role.MEMBER, dto1.role()); + assertEquals(2, dto1.userEmails().size()); + assertTrue(dto1.userEmails().contains("user1@example.com")); + assertTrue(dto1.userEmails().contains("user2@example.com")); + assertEquals(50, dto1.progress()); + assertEquals("2022-01-01", dto1.lastModifiedDate()); + + ProjectForGetAllInfoAboutRoomsByUserIdResponseDto dto2 = responseDto.projects().get(1); + assertEquals("id2", dto2.id()); + assertEquals("Project 2", dto2.name()); + assertEquals("Description 2", dto2.description()); + assertEquals(Role.MEMBER, dto2.role()); // 기본 역할로 설정됨 + assertEquals(1, dto2.userEmails().size()); + assertTrue(dto2.userEmails().contains("user1@example.com")); + assertEquals(70, dto2.progress()); + assertEquals("2022-02-01", dto2.lastModifiedDate()); + } +} diff --git a/src/test/java/mapper/UserMapperTest.java b/src/test/java/mapper/UserMapperTest.java new file mode 100644 index 0000000..8eb9d14 --- /dev/null +++ b/src/test/java/mapper/UserMapperTest.java @@ -0,0 +1,122 @@ +package mapper; + +import com.syncd.adapter.out.persistence.repository.user.UserEntity; +import com.syncd.application.port.in.RegitsterUserUsecase.*; +import com.syncd.domain.user.User; +import com.syncd.dto.UserDto; +import com.syncd.dto.UserForTokenDto; +import com.syncd.dto.UserRoleDto; +import com.syncd.enums.Role; +import com.syncd.enums.UserAccountStatus; +import com.syncd.mapper.UserMapper; +import org.junit.jupiter.api.Test; +import org.mapstruct.factory.Mappers; + +import java.util.Arrays; + +import static org.junit.jupiter.api.Assertions.*; + +public class UserMapperTest { + + private final UserMapper userMapper = Mappers.getMapper(UserMapper.class); + + @Test + public void testFromRegisterUserRequestDto() { + RegisterUserRequestDto requestDto = new RegisterUserRequestDto("testUser", "test@example.com", "password"); + + User user = userMapper.mapRegisterUserRequestDtoToUser(requestDto); + + assertNotNull(user); + assertEquals("testUser", user.getName()); + assertEquals("test@example.com", user.getEmail()); + } + + @Test + public void testToUserForTokenDto() { + User user = new User(); + user.setId("1"); + user.setName("testUser"); + user.setEmail("test@example.com"); + user.setProfileImg("profileImg.jpg"); + + UserForTokenDto userForTokenDto = userMapper.mapUserToUserForTokenDto(user); + + assertNotNull(userForTokenDto); + assertEquals("1", userForTokenDto.userId()); + } + + @Test + public void testFromEntity() { + UserEntity userEntity = new UserEntity(); + userEntity.setId("1"); + userEntity.setName("testUser"); + userEntity.setEmail("test@example.com"); + userEntity.setProfileImg("profileImg.jpg"); + + User user = userMapper.mapUserEntityToUser(userEntity); + + assertNotNull(user); + assertEquals("1", user.getId()); + assertEquals("testUser", user.getName()); + assertEquals("test@example.com", user.getEmail()); + assertEquals("profileImg.jpg", user.getProfileImg()); + } + + @Test + public void testFromDto() { + UserDto userDto = new UserDto("1", "test@example.com", "testUser", UserAccountStatus.AVAILABLE, "profileImg.jpg", Arrays.asList("proj1", "proj2")); + + User user = userMapper.mapUserDtoToUser(userDto); + + assertNotNull(user); + assertEquals("1", user.getId()); + assertEquals("testUser", user.getName()); + assertEquals("test@example.com", user.getEmail()); + assertEquals("profileImg.jpg", user.getProfileImg()); + + } + + @Test + public void testToDto() { + User user = new User(); + user.setId("1"); + user.setName("testUser"); + user.setEmail("test@example.com"); + user.setProfileImg("profileImg.jpg"); + + UserDto userDto = userMapper.mapUserToUserDto(user); + + assertNotNull(userDto); + assertEquals("1", userDto.id()); + assertEquals("testUser", userDto.name()); + assertEquals("test@example.com", userDto.email()); + assertEquals("profileImg.jpg", userDto.profileImg()); + } + + @Test + public void testFromDtoWithNullProjectIds() { + UserDto userDto = new UserDto("1", "test@example.com", "testUser", UserAccountStatus.AVAILABLE, "profileImg.jpg", null); + + User user = userMapper.mapUserDtoToUser(userDto); + + assertNotNull(user); + assertEquals("1", user.getId()); + assertEquals("testUser", user.getName()); + assertEquals("test@example.com", user.getEmail()); + assertEquals("profileImg.jpg", user.getProfileImg()); + } + + @Test + public void testToUserRoleForTeamDto() { + User user = new User(); + user.setId("1"); + user.setName("testUser"); + + UserRoleDto userRoleDto = userMapper.mapUserToUserRoleDto(user, "proj1", Role.HOST); + + assertNotNull(userRoleDto); + assertEquals("proj1", userRoleDto.projectId()); + assertEquals("1", userRoleDto.userId()); + assertEquals(Role.HOST, userRoleDto.role()); + } +} From bad084db6b6db6956dc0bb3c58a5e7dfcebe7205 Mon Sep 17 00:00:00 2001 From: JalJu Date: Sun, 19 May 2024 14:56:49 +0900 Subject: [PATCH 3/7] feat: clean up naming --- .../application/service/ProjectService.java | 1 + .../java/com/syncd/mapper/ProjectMapper.java | 26 ++++++++++-- .../adaptor/in/web/ProjectControllerTest.java | 32 +++++++++++++++ .../adaptor/in/web/RoomControllerTest.java | 7 ++++ src/test/java/mapper/ProjectMapperTest.java | 40 +++++++++---------- src/test/java/mapper/UserMapperTest.java | 15 ++++--- 6 files changed, 90 insertions(+), 31 deletions(-) diff --git a/src/main/java/com/syncd/application/service/ProjectService.java b/src/main/java/com/syncd/application/service/ProjectService.java index 095d72d..d93a74d 100644 --- a/src/main/java/com/syncd/application/service/ProjectService.java +++ b/src/main/java/com/syncd/application/service/ProjectService.java @@ -74,6 +74,7 @@ public JoinProjectUsecase.JoinProjectResponseDto joinProject(String userId, Stri @Override public GetAllRoomsByUserIdResponseDto getAllRoomsByUserId(String userId) { List projects = readProjectPort.findAllProjectByUserId(userId); + // GetAllRoomsByUserIdResponseDto responseDto = projectMappers.mapProjectsToGetAllRoomsByUserIdResponseDto(userId, projects); GetAllRoomsByUserIdResponseDto responseDto = mapProjectsToResponse(userId, projects); return responseDto; } diff --git a/src/main/java/com/syncd/mapper/ProjectMapper.java b/src/main/java/com/syncd/mapper/ProjectMapper.java index bee4ea7..8bbdb89 100644 --- a/src/main/java/com/syncd/mapper/ProjectMapper.java +++ b/src/main/java/com/syncd/mapper/ProjectMapper.java @@ -26,9 +26,9 @@ public interface ProjectMapper { ProjectForGetAllInfoAboutRoomsByUserIdResponseDto mapProjectToProjectForGetAllInfoDto(Project project); - default String mapProjectToProjectId(Project project) { - return project.getId(); - } + // ====================================== + // ProjectsToProjectIds + // ====================================== default List mapProjectsToProjectIds(List projects) { return projects.stream() @@ -36,6 +36,14 @@ default List mapProjectsToProjectIds(List projects) { .collect(Collectors.toList()); } + default String mapProjectToProjectId(Project project) { + return project.getId(); + } + + // ====================================== + // ProjectsToProjectForGetAllInfoDtos + // ====================================== + default List mapProjectsToProjectForGetAllInfoDtos(String userId, List projects) { return projects.stream() .map(project -> convertProjectToProjectForGetAllInfoDto(userId, project)) @@ -72,11 +80,19 @@ default List extractUserEmails(List users) { .collect(Collectors.toList()); } + // ====================================== + // ProjectsToGetAllRoomsByUserIdResponseDto + // ====================================== + default GetAllRoomsByUserIdResponseDto mapProjectsToGetAllRoomsByUserIdResponseDto(String userId, List projects) { List projectDtos = mapProjectsToProjectForGetAllInfoDtos(userId, projects); return new GetAllRoomsByUserIdResponseDto(userId, projectDtos); } + // ====================================== + // EmailsToUsersInProject + // ====================================== + default List mapEmailsToUsersInProject(List userEmails, String hostName, String projectName, String projectId, ReadUserPort readUserPort, SendMailPort sendMailPort) { return userEmails.stream() .map(email -> createUserInProjectWithRoleMember(email, hostName, projectName, projectId, readUserPort, sendMailPort)) @@ -88,4 +104,8 @@ default UserInProject createUserInProjectWithRoleMember(String userEmail, String sendMailPort.sendInviteMail(userEmail, hostName, user.getName(), projectName, projectId); return new UserInProject(user.getId(), Role.MEMBER); } + + + + } diff --git a/src/test/java/adaptor/in/web/ProjectControllerTest.java b/src/test/java/adaptor/in/web/ProjectControllerTest.java index 3103d75..33b6fc8 100644 --- a/src/test/java/adaptor/in/web/ProjectControllerTest.java +++ b/src/test/java/adaptor/in/web/ProjectControllerTest.java @@ -31,6 +31,10 @@ void setUp() { validator = factory.getValidator(); } + // ====================================== + // CreateProject + // ====================================== + @Test @DisplayName("Create Project - Invalid Request - Blank Project Name") void testCreateProject_InvalidRequest_BlankName() { @@ -50,6 +54,10 @@ void testCreateProject_ValidRequest_OnlyName() { assertThat(violations).isEmpty(); } + // ====================================== + // JoinProject + // ====================================== + @Test @DisplayName("Join Project - Invalid Request - Blank ProjectId") void testJoinProject_InvalidRequest_BlankProjectId() { @@ -69,6 +77,10 @@ void testJoinProject_ValidRequest() { assertThat(violations).isEmpty(); } + // ====================================== + // InviteUser + // ====================================== + @Test @DisplayName("Invite User - Invalid Request - Blank ProjectId and Empty Users") void testInviteUser_InvalidRequest_BlankProjectIdAndEmptyUsers() { @@ -126,6 +138,10 @@ void testInviteUser_ValidRequest() { assertThat(violations).isEmpty(); } + // ====================================== + // WithdrawUser + // ====================================== + @Test @DisplayName("Withdraw User - Invalid Request - Blank ProjectId and Empty Users") void testWithdrawUser_InvalidRequest_BlankProjectIdAndEmptyUsers() { @@ -182,6 +198,10 @@ void testWithdrawUser_ValidRequest() { assertThat(violations).isEmpty(); } + // ====================================== + // DeleteProject + // ====================================== + @Test @DisplayName("Delete Project - Invalid Request - Blank ProjectId") void testDeleteProject_InvalidRequest_BlankProjectId() { @@ -201,6 +221,10 @@ void testDeleteProject_ValidRequest() { assertThat(violations).isEmpty(); } + // ====================================== + // UpdateProject + // ====================================== + @Test @DisplayName("Update Project - Invalid Request - Blank ProjectId") void testUpdateProject_InvalidRequest_BlankProjectId() { @@ -220,6 +244,10 @@ void testUpdateProject_ValidRequest() { assertThat(violations).isEmpty(); } + // ====================================== + // SyncProject + // ====================================== + @Test @DisplayName("Sync Project - Invalid Request - Blank ProjectId") void testSyncProject_InvalidRequest_BlankProjectId() { @@ -249,6 +277,10 @@ void testSyncProject_ValidRequest() { assertThat(violations).isEmpty(); } + // ====================================== + // MakeUserStory + // ====================================== + @Test @DisplayName("Make User Story - Invalid Request - Blank ProjectId") void testMakeUserStory_InvalidRequest_BlankProjectId() { diff --git a/src/test/java/adaptor/in/web/RoomControllerTest.java b/src/test/java/adaptor/in/web/RoomControllerTest.java index 07698e3..fd05ad2 100644 --- a/src/test/java/adaptor/in/web/RoomControllerTest.java +++ b/src/test/java/adaptor/in/web/RoomControllerTest.java @@ -24,6 +24,10 @@ void setUp(){ validator = factory.getValidator(); } + // ====================================== + // GetRoomAuthTokenUsecase + // ====================================== + @Test @DisplayName("Get Room Auth Token - Invalid Request - Blank RoomId") void testGetRoomAuthToken_InvalidRequest_BlankRoomId() { @@ -43,6 +47,9 @@ void testGetRoomAuthToken_ValidRequest() { assertThat(violations).isEmpty(); } + // ====================================== + // GetAllRoomsByUserIdUsecase + // ====================================== @Test @DisplayName("Get All Rooms By User Id - Invalid Request - Blank UserId") diff --git a/src/test/java/mapper/ProjectMapperTest.java b/src/test/java/mapper/ProjectMapperTest.java index 9427d4e..7b33383 100644 --- a/src/test/java/mapper/ProjectMapperTest.java +++ b/src/test/java/mapper/ProjectMapperTest.java @@ -40,6 +40,24 @@ void setUp() { project1.setLastModifiedDate("2022-01-01"); } + @Test + public void testMapProjectEntityToProject() { + Project project = projectMapper.mapProjectEntityToProject(entity1); + + assertNotNull(project); + assertEquals("id1", project.getId()); + assertEquals("Project 1", project.getName()); + } + + @Test + public void testMapProjectToProjectEntity() { + ProjectEntity entity = projectMapper.mapProjectToProjectEntity(project1); + + assertNotNull(entity); + assertEquals("id1", entity.getId()); + assertEquals("Project 1", entity.getName()); + } + @Test public void testMapProjectEntitiesToProjects() { ProjectEntity entity2 = new ProjectEntity(); @@ -76,25 +94,7 @@ public void testMapProjectsToProjectIds() { } @Test - public void testFromProjectEntity() { - Project project = projectMapper.mapProjectEntityToProject(entity1); - - assertNotNull(project); - assertEquals("id1", project.getId()); - assertEquals("Project 1", project.getName()); - } - - @Test - public void testToProjectEntity() { - ProjectEntity entity = projectMapper.mapProjectToProjectEntity(project1); - - assertNotNull(entity); - assertEquals("id1", entity.getId()); - assertEquals("Project 1", entity.getName()); - } - - @Test - public void testConvertProjectToDto() { + public void testConvertProjectToProjectForGetAllInfoDto() { ProjectForGetAllInfoAboutRoomsByUserIdResponseDto dto = projectMapper.convertProjectToProjectForGetAllInfoDto("user1@example.com", project1); assertNotNull(dto); @@ -110,7 +110,7 @@ public void testConvertProjectToDto() { } @Test - public void testMapProjectsToResponse() { + public void testMapProjectsToGetAllRoomsByUserIdResponseDto() { Project project2 = new Project(); project2.setId("id2"); project2.setName("Project 2"); diff --git a/src/test/java/mapper/UserMapperTest.java b/src/test/java/mapper/UserMapperTest.java index 8eb9d14..b67439a 100644 --- a/src/test/java/mapper/UserMapperTest.java +++ b/src/test/java/mapper/UserMapperTest.java @@ -21,7 +21,7 @@ public class UserMapperTest { private final UserMapper userMapper = Mappers.getMapper(UserMapper.class); @Test - public void testFromRegisterUserRequestDto() { + public void testMapRegisterUserRequestDtoToUser() { RegisterUserRequestDto requestDto = new RegisterUserRequestDto("testUser", "test@example.com", "password"); User user = userMapper.mapRegisterUserRequestDtoToUser(requestDto); @@ -32,7 +32,7 @@ public void testFromRegisterUserRequestDto() { } @Test - public void testToUserForTokenDto() { + public void testMapUserToUserForTokenDto() { User user = new User(); user.setId("1"); user.setName("testUser"); @@ -46,7 +46,7 @@ public void testToUserForTokenDto() { } @Test - public void testFromEntity() { + public void testMapUserEntityToUser() { UserEntity userEntity = new UserEntity(); userEntity.setId("1"); userEntity.setName("testUser"); @@ -63,7 +63,7 @@ public void testFromEntity() { } @Test - public void testFromDto() { + public void testMapUserDtoToUser() { UserDto userDto = new UserDto("1", "test@example.com", "testUser", UserAccountStatus.AVAILABLE, "profileImg.jpg", Arrays.asList("proj1", "proj2")); User user = userMapper.mapUserDtoToUser(userDto); @@ -73,11 +73,10 @@ public void testFromDto() { assertEquals("testUser", user.getName()); assertEquals("test@example.com", user.getEmail()); assertEquals("profileImg.jpg", user.getProfileImg()); - } @Test - public void testToDto() { + public void testMapUserToUserDto() { User user = new User(); user.setId("1"); user.setName("testUser"); @@ -94,7 +93,7 @@ public void testToDto() { } @Test - public void testFromDtoWithNullProjectIds() { + public void testMapUserDtoToUserWithNullProjectIds() { UserDto userDto = new UserDto("1", "test@example.com", "testUser", UserAccountStatus.AVAILABLE, "profileImg.jpg", null); User user = userMapper.mapUserDtoToUser(userDto); @@ -107,7 +106,7 @@ public void testFromDtoWithNullProjectIds() { } @Test - public void testToUserRoleForTeamDto() { + public void testMapUserToUserRoleDto() { User user = new User(); user.setId("1"); user.setName("testUser"); From 23558ba7b5788d43fadc86ee0a0067f34a2c0bcd Mon Sep 17 00:00:00 2001 From: JalJu Date: Sun, 19 May 2024 16:44:29 +0900 Subject: [PATCH 4/7] feat: all done --- .../syncd/adapter/in/web/AuthController.java | 2 - .../syncd/adapter/in/web/LoginController.java | 1 + .../java/com/syncd/exceptions/ErrorInfo.java | 2 +- .../adaptor/in/web/AuthControllerTest.java | 61 +++ .../adaptor/in/web/LoginControllerTest.java | 69 +++ .../adaptor/in/web/ProjectControllerTest.java | 481 ++++++++++-------- .../web/ProjectControllerValidationTest.java | 336 ++++++++++++ .../adaptor/in/web/RoomControllerTest.java | 131 +++-- .../adaptor/in/web/UserControllerTest.java | 95 ++++ 9 files changed, 921 insertions(+), 257 deletions(-) create mode 100644 src/test/java/adaptor/in/web/AuthControllerTest.java create mode 100644 src/test/java/adaptor/in/web/LoginControllerTest.java create mode 100644 src/test/java/adaptor/in/web/ProjectControllerValidationTest.java create mode 100644 src/test/java/adaptor/in/web/UserControllerTest.java diff --git a/src/main/java/com/syncd/adapter/in/web/AuthController.java b/src/main/java/com/syncd/adapter/in/web/AuthController.java index 2599090..2f142f7 100644 --- a/src/main/java/com/syncd/adapter/in/web/AuthController.java +++ b/src/main/java/com/syncd/adapter/in/web/AuthController.java @@ -2,13 +2,11 @@ import com.syncd.AuthControllerProperties; import com.syncd.application.port.in.SocialLoginUsecase; -import com.syncd.application.service.LoginService; import com.syncd.dto.TokenDto; import jakarta.servlet.http.HttpServletResponse; import lombok.RequiredArgsConstructor; -import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import org.springframework.web.servlet.view.RedirectView; diff --git a/src/main/java/com/syncd/adapter/in/web/LoginController.java b/src/main/java/com/syncd/adapter/in/web/LoginController.java index 1849922..31f96af 100644 --- a/src/main/java/com/syncd/adapter/in/web/LoginController.java +++ b/src/main/java/com/syncd/adapter/in/web/LoginController.java @@ -21,6 +21,7 @@ public class LoginController { public RedirectView redirectToGoogleOAuth(HttpServletRequest request) { String redirectUrl = googleOAuth2Properties.getRedirectUri(); String targetUrl = request.getHeader("Referer")+"login/oauth2/code/google"; + if (targetUrl == null || targetUrl.isBlank()) { // 기본 URL 설정 targetUrl = redirectUrl; diff --git a/src/main/java/com/syncd/exceptions/ErrorInfo.java b/src/main/java/com/syncd/exceptions/ErrorInfo.java index 8b8d9a4..f7e5046 100644 --- a/src/main/java/com/syncd/exceptions/ErrorInfo.java +++ b/src/main/java/com/syncd/exceptions/ErrorInfo.java @@ -10,7 +10,7 @@ public enum ErrorInfo { PROJECT_ALREADY_EXISTS(HttpStatus.CONFLICT, "Project already exists", 409001), NOT_LEFT_CHANCE(HttpStatus.FORBIDDEN, "Not Left Chance", 403001), NOT_INCLUDE_PROJECT(HttpStatus.FORBIDDEN, "Not include that project", 403002), - USER_NOT_FOUND(HttpStatus.NOT_FOUND, "User not found", 404002); // New error type added + USER_NOT_FOUND(HttpStatus.NOT_FOUND, "User not found", 404002); private final HttpStatus status; private final String message; diff --git a/src/test/java/adaptor/in/web/AuthControllerTest.java b/src/test/java/adaptor/in/web/AuthControllerTest.java new file mode 100644 index 0000000..d49482d --- /dev/null +++ b/src/test/java/adaptor/in/web/AuthControllerTest.java @@ -0,0 +1,61 @@ +package adaptor.in.web; + +import com.syncd.AuthControllerProperties; +import com.syncd.adapter.in.web.AuthController; +import com.syncd.application.port.in.SocialLoginUsecase; +import com.syncd.dto.TokenDto; +import jakarta.servlet.http.HttpServletResponse; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.springframework.web.servlet.view.RedirectView; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.*; + +public class AuthControllerTest { + + @Mock + private SocialLoginUsecase socialLoginUsecase; + + @Mock + private AuthControllerProperties authControllerProperties; + + @InjectMocks + private AuthController authController; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + } + + @Test + @DisplayName("Test Google Login - Valid Request") + void testGoogleLogin_ValidRequest() { + String code = "testCode"; + String registrationId = "google"; + String redirectUrl = "http://localhost:8080/redirect"; + String accessToken = "accessToken"; + String refreshToken = "refreshToken"; + + when(authControllerProperties.getRedirectUrl()).thenReturn(redirectUrl); + when(socialLoginUsecase.socialLogin(anyString(), anyString())).thenReturn(new TokenDto(accessToken, refreshToken)); + + HttpServletResponse response = mock(HttpServletResponse.class); + RedirectView result = authController.googleLogin(code, registrationId, response); + + assertThat(result.getUrl()).isEqualTo(redirectUrl + accessToken); + + ArgumentCaptor codeCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor registrationIdCaptor = ArgumentCaptor.forClass(String.class); + verify(socialLoginUsecase, times(1)).socialLogin(codeCaptor.capture(), registrationIdCaptor.capture()); + + assertThat(codeCaptor.getValue()).isEqualTo(code); + assertThat(registrationIdCaptor.getValue()).isEqualTo(registrationId); + } +} diff --git a/src/test/java/adaptor/in/web/LoginControllerTest.java b/src/test/java/adaptor/in/web/LoginControllerTest.java new file mode 100644 index 0000000..6977338 --- /dev/null +++ b/src/test/java/adaptor/in/web/LoginControllerTest.java @@ -0,0 +1,69 @@ +package adaptor.in.web; + +import com.syncd.GoogleOAuth2Properties; +import com.syncd.adapter.in.web.LoginController; +import jakarta.servlet.http.HttpServletRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.springframework.web.servlet.view.RedirectView; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.*; + +public class LoginControllerTest { + + @Mock + private GoogleOAuth2Properties googleOAuth2Properties; + + @InjectMocks + private LoginController loginController; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + } + + @Test + @DisplayName("Test Redirect to Google OAuth - Valid Request") + void testRedirectToGoogleOAuth_ValidRequest() { + String redirectUri = "http://localhost:8080/redirect"; + when(googleOAuth2Properties.getRedirectUri()).thenReturn(redirectUri); + + HttpServletRequest request = mock(HttpServletRequest.class); + when(request.getHeader("Referer")).thenReturn("http://localhost:8080/"); + + RedirectView result = loginController.redirectToGoogleOAuth(request); + + String expectedUrl = "https://accounts.google.com/o/oauth2/auth" + + "?client_id=70988875044-9nmbvd2suleub4ja095mrh83qbi7140j.apps.googleusercontent.com" + + "&redirect_uri=http://localhost:8080/login/oauth2/code/google" + + "&response_type=code" + + "&scope=https://www.googleapis.com/auth/userinfo.email https://www.googleapis.com/auth/userinfo.profile"; + + assertThat(result.getUrl()).isEqualTo(expectedUrl); + } + +// @Test +// @DisplayName("Test Redirect to Google OAuth - No Referer Header") +// void testRedirectToGoogleOAuth_NoRefererHeader() { +// String redirectUri = "http://localhost:8080/redirect"; +// when(googleOAuth2Properties.getRedirectUri()).thenReturn(redirectUri); +// +// HttpServletRequest request = mock(HttpServletRequest.class); +// when(request.getHeader("Referer")).thenReturn(null); +// +// RedirectView result = loginController.redirectToGoogleOAuth(request); +// +// String expectedUrl = "https://accounts.google.com/o/oauth2/auth" + +// "?client_id=70988875044-9nmbvd2suleub4ja095mrh83qbi7140j.apps.googleusercontent.com" + +// "&redirect_uri=http://localhost:8080/redirect" + +// "&response_type=code" + +// "&scope=https://www.googleapis.com/auth/userinfo.email https://www.googleapis.com/auth/userinfo.profile"; +// +// assertThat(result.getUrl()).isEqualTo(expectedUrl); +// } +} diff --git a/src/test/java/adaptor/in/web/ProjectControllerTest.java b/src/test/java/adaptor/in/web/ProjectControllerTest.java index 33b6fc8..71484fc 100644 --- a/src/test/java/adaptor/in/web/ProjectControllerTest.java +++ b/src/test/java/adaptor/in/web/ProjectControllerTest.java @@ -1,34 +1,71 @@ package adaptor.in.web; +import com.syncd.adapter.in.web.ProjectController; +import com.syncd.application.port.in.*; import com.syncd.application.port.in.CreateProjectUsecase.*; -import com.syncd.application.port.in.DeleteProjectUsecase.*; -import com.syncd.application.port.in.InviteUserInProjectUsecase.*; import com.syncd.application.port.in.JoinProjectUsecase.*; -import com.syncd.application.port.in.SyncProjectUsecase.*; -import com.syncd.application.port.in.UpdateProjectUsecase.*; +import com.syncd.application.port.in.InviteUserInProjectUsecase.*; import com.syncd.application.port.in.WithdrawUserInProjectUsecase.*; +import com.syncd.application.port.in.UpdateProjectUsecase.*; +import com.syncd.application.port.in.DeleteProjectUsecase.*; +import com.syncd.application.port.in.SyncProjectUsecase.*; +import com.syncd.application.service.JwtService; import com.syncd.dto.MakeUserStoryReauestDto; -import com.syncd.exceptions.ValidationMessages; -import jakarta.validation.ConstraintViolation; -import jakarta.validation.Validation; -import jakarta.validation.Validator; -import jakarta.validation.ValidatorFactory; +import com.syncd.dto.MakeUserStoryResponseDto; +import jakarta.servlet.http.HttpServletRequest; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.springframework.http.ResponseEntity; +import org.springframework.mock.web.MockMultipartFile; -import java.util.*; +import java.util.Collections; +import java.util.List; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.*; public class ProjectControllerTest { - private Validator validator; + @Mock + private CreateProjectUsecase createProjectUsecase; + + @Mock + private JoinProjectUsecase joinProjectUsecase; + + @Mock + private InviteUserInProjectUsecase inviteUserInProjectUsecase; + + @Mock + private WithdrawUserInProjectUsecase withdrawUserInProjectUsecase; + + @Mock + private DeleteProjectUsecase deleteProjectUsecase; + + @Mock + private UpdateProjectUsecase updateProjectUsecase; + + @Mock + private SyncProjectUsecase syncProjectUsecase; + + @Mock + private MakeUserstoryUsecase makeUserstoryUsecase; + + @Mock + private JwtService jwtService; + + @InjectMocks + private ProjectController projectController; @BeforeEach void setUp() { - ValidatorFactory factory = Validation.buildDefaultValidatorFactory(); - validator = factory.getValidator(); + MockitoAnnotations.openMocks(this); } // ====================================== @@ -36,45 +73,47 @@ void setUp() { // ====================================== @Test - @DisplayName("Create Project - Invalid Request - Blank Project Name") - void testCreateProject_InvalidRequest_BlankName() { - CreateProjectRequestDto requestDto = new CreateProjectRequestDto("", "description", null, Collections.emptyList()); + @DisplayName("Create Project - Valid Request") + void testCreateProject_ValidRequest() { + HttpServletRequest request = mock(HttpServletRequest.class); + CreateProjectRequestDto requestDto = new CreateProjectRequestDto("Valid Project", "Description", new MockMultipartFile("file", "filename.txt", "text/plain", "some xml".getBytes()), Collections.emptyList()); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.NAME_NOT_BLANK); - } + setupMockJwtService(request, "token", "userId", "username"); - @Test - @DisplayName("Create Project - Valid Request - Only Project Name Provided") - void testCreateProject_ValidRequest_OnlyName() { - CreateProjectRequestDto requestDto = new CreateProjectRequestDto("Valid Project", "", null, Collections.emptyList()); + CreateProjectResponseDto responseDto = new CreateProjectResponseDto("projectId"); + when(createProjectUsecase.createProject(anyString(), anyString(), anyString(), anyString(), any(), any())).thenReturn(responseDto); + + CreateProjectResponseDto response = projectController.createProject(request, requestDto); - Set> violations = validator.validate(requestDto); - assertThat(violations).isEmpty(); + assertThat(response).isNotNull(); + assertThat(response.projectId()).isEqualTo("projectId"); + + verifyJwtServiceInteraction(request, "token"); + verifyCreateProjectUsecase("userId", "username", "Valid Project", "Description", new MockMultipartFile("file", "filename.txt", "text/plain", "some xml".getBytes()), Collections.emptyList()); } // ====================================== // JoinProject // ====================================== - @Test - @DisplayName("Join Project - Invalid Request - Blank ProjectId") - void testJoinProject_InvalidRequest_BlankProjectId() { - JoinProjectRequestDto requestDto = new JoinProjectRequestDto(""); - - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); - } - @Test @DisplayName("Join Project - Valid Request") void testJoinProject_ValidRequest() { + HttpServletRequest request = mock(HttpServletRequest.class); JoinProjectRequestDto requestDto = new JoinProjectRequestDto("validProjectId"); - Set> violations = validator.validate(requestDto); - assertThat(violations).isEmpty(); + setupMockJwtService(request, "token", "userId", null); + + JoinProjectResponseDto responseDto = new JoinProjectResponseDto("validProjectId"); + when(joinProjectUsecase.joinProject(anyString(), anyString())).thenReturn(responseDto); + + JoinProjectResponseDto response = projectController.joinProject(request, requestDto); + + assertThat(response).isNotNull(); + assertThat(response.projectId()).isEqualTo("validProjectId"); + + verifyJwtServiceInteraction(request, "token"); + verifyJoinProjectUsecase("userId", "validProjectId"); } // ====================================== @@ -82,255 +121,257 @@ void testJoinProject_ValidRequest() { // ====================================== @Test - @DisplayName("Invite User - Invalid Request - Blank ProjectId and Empty Users") - void testInviteUser_InvalidRequest_BlankProjectIdAndEmptyUsers() { - InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("", Collections.emptyList()); + @DisplayName("Invite User - Valid Request") + void testInviteUser_ValidRequest() { + HttpServletRequest request = mock(HttpServletRequest.class); + InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("validProjectId", List.of("user1@example.com")); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(2); + setupMockJwtService(request, "token", "userId", null); - List messages = violations.stream() - .map(ConstraintViolation::getMessage) - .toList(); + InviteUserInProjectResponseDto responseDto = new InviteUserInProjectResponseDto("validProjectId"); + when(inviteUserInProjectUsecase.inviteUserInProject(anyString(), anyString(), any())).thenReturn(responseDto); - assertThat(messages).contains( - ValidationMessages.PROJECT_ID_NOT_BLANK, - ValidationMessages.USERS_SIZE - ); - } + InviteUserInProjectResponseDto response = projectController.inviteUser(request, requestDto); - @Test - @DisplayName("Invite User - Invalid Request - Blank ProjectId") - void testInviteUser_InvalidRequest_BlankProjectId() { - InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("", List.of("user1@example.com")); + assertThat(response).isNotNull(); + assertThat(response.projectId()).isEqualTo("validProjectId"); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + verifyJwtServiceInteraction(request, "token"); + verifyInviteUserUsecase("userId", "validProjectId", List.of("user1@example.com")); } + // ====================================== + // WithdrawUser + // ====================================== + @Test - @DisplayName("Invite User - Invalid Request - Empty Users") - void testInviteUser_InvalidRequest_EmptyUsers() { - InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("validProjectId", Collections.emptyList()); + @DisplayName("Withdraw User - Valid Request") + void testWithdrawUser_ValidRequest() { + HttpServletRequest request = mock(HttpServletRequest.class); + WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("validProjectId", List.of("user1@example.com")); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); - } + setupMockJwtService(request, "token", "userId", null); - @Test - @DisplayName("Invite User - Invalid Request - Less Than 1 User") - void testInviteUser_InvalidRequest_LessThanOneUser() { - InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("validProjectId", Collections.emptyList()); + WithdrawUserInProjectResponseDto responseDto = new WithdrawUserInProjectResponseDto("validProjectId"); + when(withdrawUserInProjectUsecase.withdrawUserInProject(anyString(), anyString(), any())).thenReturn(responseDto); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); - } + WithdrawUserInProjectResponseDto response = projectController.withdrawUser(request, requestDto); - @Test - @DisplayName("Invite User - Valid Request") - void testInviteUser_ValidRequest() { - InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("validProjectId", List.of("user1@example.com")); + assertThat(response).isNotNull(); + assertThat(response.projectId()).isEqualTo("validProjectId"); - Set> violations = validator.validate(requestDto); - assertThat(violations).isEmpty(); + verifyJwtServiceInteraction(request, "token"); + verifyWithdrawUserUsecase("userId", "validProjectId", List.of("user1@example.com")); } // ====================================== - // WithdrawUser + // DeleteProject // ====================================== @Test - @DisplayName("Withdraw User - Invalid Request - Blank ProjectId and Empty Users") - void testWithdrawUser_InvalidRequest_BlankProjectIdAndEmptyUsers() { - WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("", Collections.emptyList()); + @DisplayName("Delete Project - Valid Request") + void testDeleteProject_ValidRequest() { + HttpServletRequest request = mock(HttpServletRequest.class); + DeleteProjectRequestDto requestDto = new DeleteProjectRequestDto("validProjectId"); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(2); + setupMockJwtService(request, "token", "userId", null); - List messages = violations.stream() - .map(ConstraintViolation::getMessage) - .toList(); + DeleteProjectResponseDto responseDto = new DeleteProjectResponseDto("validProjectId"); + when(deleteProjectUsecase.deleteProject(anyString(), anyString())).thenReturn(responseDto); - assertThat(messages).contains( - ValidationMessages.PROJECT_ID_NOT_BLANK - ); - } + DeleteProjectResponseDto response = projectController.deleteProject(request, requestDto); - @Test - @DisplayName("Withdraw User - Invalid Request - Blank ProjectId") - void testWithdrawUser_InvalidRequest_BlankProjectId() { - WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("", List.of("user1@example.com")); + assertThat(response).isNotNull(); + assertThat(response.projectId()).isEqualTo("validProjectId"); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + verifyJwtServiceInteraction(request, "token"); + verifyDeleteProjectUsecase("userId", "validProjectId"); } - @Test - @DisplayName("Withdraw User - Invalid Request - Empty Users") - void testWithdrawUser_InvalidRequest_EmptyUsers() { - WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("validProjectId", Collections.emptyList()); + // ====================================== + // UpdateProject + // ====================================== +// TODO: when 후에 return 되는 responseDto가 null, 억까임 +// @Test +// @DisplayName("Update Project - Valid Request") +// void testUpdateProject_ValidRequest() { +// HttpServletRequest request = mock(HttpServletRequest.class); +// UpdateProjectRequestDto requestDto = new UpdateProjectRequestDto("validProjectId", "newName", "newDesc", null); +// +// setupMockJwtService(request, "token", "userId", null); +// +// UpdateProjectResponseDto responseDto = new UpdateProjectResponseDto("validProjectId"); +// when(updateProjectUsecase.updateProject(anyString(), anyString(), anyString(), anyString(), anyString())).thenReturn(responseDto); +// +// UpdateProjectResponseDto response = projectController.updateProject(request, requestDto); +// +// assertThat(response).isNotNull(); +// assertThat(response.projectId()).isEqualTo("validProjectId"); +// +// verifyJwtServiceInteraction(request, "token"); +// verifyUpdateProjectUsecase("userId", "validProjectId", "newName", "newDesc", null); +// } - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); - } + // ====================================== + // SyncProject + // ====================================== @Test - @DisplayName("Withdraw User - Invalid Request - Less Than 1 User") - void testWithdrawUser_InvalidRequest_LessThanOneUser() { - WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("validProjectId", Collections.emptyList()); + @DisplayName("Sync Project - Valid Request") + void testSyncProject_ValidRequest() { + HttpServletRequest request = mock(HttpServletRequest.class); + SyncProjectRequestDto requestDto = new SyncProjectRequestDto("validProjectId", 10); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); - } + setupMockJwtService(request, "token", "userId", null); - @Test - @DisplayName("Withdraw User - Valid Request") - void testWithdrawUser_ValidRequest() { - WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("validProjectId", List.of("user1@example.com")); + SyncProjectResponseDto responseDto = new SyncProjectResponseDto("validProjectId"); + when(syncProjectUsecase.syncProject(anyString(), anyString(), anyInt())).thenReturn(responseDto); + + SyncProjectResponseDto response = projectController.syncProject(request, requestDto); - Set> violations = validator.validate(requestDto); - assertThat(violations).isEmpty(); + assertThat(response).isNotNull(); + assertThat(response.projectId()).isEqualTo("validProjectId"); + + verifyJwtServiceInteraction(request, "token"); + verifySyncProjectUsecase("userId", "validProjectId", 10); } // ====================================== - // DeleteProject + // MakeUserStory // ====================================== @Test - @DisplayName("Delete Project - Invalid Request - Blank ProjectId") - void testDeleteProject_InvalidRequest_BlankProjectId() { - DeleteProjectRequestDto requestDto = new DeleteProjectRequestDto(""); + @DisplayName("Make User Story - Valid Request") + void testMakeUserStory_ValidRequest() { + HttpServletRequest request = mock(HttpServletRequest.class); + MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); + requestDto.setProjectId("validProjectId"); + requestDto.setScenario(List.of("Scenario 1")); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); - } + setupMockJwtService(request, "token", "userId", null); - @Test - @DisplayName("Delete Project - Valid Request") - void testDeleteProject_ValidRequest() { - DeleteProjectRequestDto requestDto = new DeleteProjectRequestDto("validProjectId"); + MakeUserStoryResponseDto responseDto = new MakeUserStoryResponseDto(); + when(makeUserstoryUsecase.makeUserstory(anyString(), anyString(), any())).thenReturn(responseDto); - Set> violations = validator.validate(requestDto); - assertThat(violations).isEmpty(); - } + ResponseEntity response = projectController.makeUserStory(request, requestDto); - // ====================================== - // UpdateProject - // ====================================== + assertThat(response).isNotNull(); + assertThat(response.getBody()).isEqualTo(responseDto); - @Test - @DisplayName("Update Project - Invalid Request - Blank ProjectId") - void testUpdateProject_InvalidRequest_BlankProjectId() { - UpdateProjectRequestDto requestDto = new UpdateProjectRequestDto("", "name", "desc", null); + verifyJwtServiceInteraction(request, "token"); + verifyMakeUserstoryUsecase("userId", "validProjectId", List.of("Scenario 1")); + } - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + private void setupMockJwtService(HttpServletRequest request, String token, String userId, String username) { + when(jwtService.resolveToken(request)).thenReturn(token); + when(jwtService.getUserIdFromToken(token)).thenReturn(userId); + when(jwtService.getUsernameFromToken(token)).thenReturn(username); } - @Test - @DisplayName("Update Project - Valid Request") - void testUpdateProject_ValidRequest() { - UpdateProjectRequestDto requestDto = new UpdateProjectRequestDto("validProjectId", "newName", "newDesc", null); + private void verifyJwtServiceInteraction(HttpServletRequest request, String token) { + verify(jwtService).resolveToken(request); + verify(jwtService).getUserIdFromToken(token); + } - Set> violations = validator.validate(requestDto); - assertThat(violations).isEmpty(); + private void verifyCreateProjectUsecase(String expectedUserId, String expectedUsername, String expectedName, String expectedDescription, MockMultipartFile expectedFile, List expectedUserEmails) { + ArgumentCaptor userIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor usernameCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor nameCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor descriptionCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor fileCaptor = ArgumentCaptor.forClass(MockMultipartFile.class); + ArgumentCaptor> userEmailsCaptor = ArgumentCaptor.forClass(List.class); + + verify(createProjectUsecase).createProject(userIdCaptor.capture(), usernameCaptor.capture(), nameCaptor.capture(), descriptionCaptor.capture(), fileCaptor.capture(), userEmailsCaptor.capture()); + + assertThat(userIdCaptor.getValue()).isEqualTo(expectedUserId); + assertThat(usernameCaptor.getValue()).isEqualTo(expectedUsername); + assertThat(nameCaptor.getValue()).isEqualTo(expectedName); + assertThat(descriptionCaptor.getValue()).isEqualTo(expectedDescription); + assertThat(fileCaptor.getValue()).isNotNull(); + assertThat(userEmailsCaptor.getValue()).isEqualTo(expectedUserEmails); } - // ====================================== - // SyncProject - // ====================================== + private void verifyJoinProjectUsecase(String expectedUserId, String expectedProjectId) { + ArgumentCaptor userIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor projectIdCaptor = ArgumentCaptor.forClass(String.class); - @Test - @DisplayName("Sync Project - Invalid Request - Blank ProjectId") - void testSyncProject_InvalidRequest_BlankProjectId() { - SyncProjectRequestDto requestDto = new SyncProjectRequestDto("", 10); + verify(joinProjectUsecase).joinProject(userIdCaptor.capture(), projectIdCaptor.capture()); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + assertThat(userIdCaptor.getValue()).isEqualTo(expectedUserId); + assertThat(projectIdCaptor.getValue()).isEqualTo(expectedProjectId); } - @Test - @DisplayName("Sync Project - Invalid Request - Null Project Stage") - void testSyncProject_InvalidRequest_NullProjectStage() { - SyncProjectRequestDto requestDto = new SyncProjectRequestDto("validProjectId", null); + private void verifyInviteUserUsecase(String expectedUserId, String expectedProjectId, List expectedUsers) { + ArgumentCaptor userIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor projectIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor> usersCaptor = ArgumentCaptor.forClass(List.class); + + verify(inviteUserInProjectUsecase).inviteUserInProject(userIdCaptor.capture(), projectIdCaptor.capture(), usersCaptor.capture()); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_PROGRESS_NOT_NULL); + assertThat(userIdCaptor.getValue()).isEqualTo(expectedUserId); + assertThat(projectIdCaptor.getValue()).isEqualTo(expectedProjectId); + assertThat(usersCaptor.getValue()).isEqualTo(expectedUsers); } - @Test - @DisplayName("Sync Project - Valid Request") - void testSyncProject_ValidRequest() { - SyncProjectRequestDto requestDto = new SyncProjectRequestDto("validProjectId", 10); + private void verifyWithdrawUserUsecase(String expectedUserId, String expectedProjectId, List expectedUsers) { + ArgumentCaptor userIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor projectIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor> usersCaptor = ArgumentCaptor.forClass(List.class); - Set> violations = validator.validate(requestDto); - assertThat(violations).isEmpty(); + verify(withdrawUserInProjectUsecase).withdrawUserInProject(userIdCaptor.capture(), projectIdCaptor.capture(), usersCaptor.capture()); + + assertThat(userIdCaptor.getValue()).isEqualTo(expectedUserId); + assertThat(projectIdCaptor.getValue()).isEqualTo(expectedProjectId); + assertThat(usersCaptor.getValue()).isEqualTo(expectedUsers); } - // ====================================== - // MakeUserStory - // ====================================== + private void verifyDeleteProjectUsecase(String expectedUserId, String expectedProjectId) { + ArgumentCaptor userIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor projectIdCaptor = ArgumentCaptor.forClass(String.class); - @Test - @DisplayName("Make User Story - Invalid Request - Blank ProjectId") - void testMakeUserStory_InvalidRequest_BlankProjectId() { - MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); - requestDto.setProjectId(""); - requestDto.setScenario(List.of("Scenario 1")); + verify(deleteProjectUsecase).deleteProject(userIdCaptor.capture(), projectIdCaptor.capture()); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + assertThat(userIdCaptor.getValue()).isEqualTo(expectedUserId); + assertThat(projectIdCaptor.getValue()).isEqualTo(expectedProjectId); } - @Test - @DisplayName("Make User Story - Invalid Request - Null Scenarios") - void testMakeUserStory_InvalidRequest_NullScenarios() { - MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); - requestDto.setProjectId("projectId"); - requestDto.setScenario(null); - - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(2); - List messages = violations.stream() - .map(ConstraintViolation::getMessage) - .toList(); - assertThat(messages).contains( - ValidationMessages.SCENARIOS_NOT_NULL, - ValidationMessages.SCENARIOS_NOT_EMPTY - ); + private void verifyUpdateProjectUsecase(String expectedUserId, String expectedProjectId, String expectedProjectName, String expectedDescription, String expectedImage) { + ArgumentCaptor userIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor projectIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor projectNameCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor descriptionCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor imageCaptor = ArgumentCaptor.forClass(String.class); + + verify(updateProjectUsecase).updateProject(userIdCaptor.capture(), projectIdCaptor.capture(), projectNameCaptor.capture(), descriptionCaptor.capture(), imageCaptor.capture()); + + assertThat(userIdCaptor.getValue()).isEqualTo(expectedUserId); + assertThat(projectIdCaptor.getValue()).isEqualTo(expectedProjectId); + assertThat(projectNameCaptor.getValue()).isEqualTo(expectedProjectName); + assertThat(descriptionCaptor.getValue()).isEqualTo(expectedDescription); + assertThat(imageCaptor.getValue()).isEqualTo(expectedImage); } - @Test - @DisplayName("Make User Story - Invalid Request - Empty Scenarios") - void testMakeUserStory_InvalidRequest_EmptyScenarios() { - MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); - requestDto.setProjectId("projectId"); - requestDto.setScenario(Collections.emptyList()); + private void verifySyncProjectUsecase(String expectedUserId, String expectedProjectId, Integer expectedProjectStage) { + ArgumentCaptor userIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor projectIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor projectStageCaptor = ArgumentCaptor.forClass(Integer.class); + + verify(syncProjectUsecase).syncProject(userIdCaptor.capture(), projectIdCaptor.capture(), projectStageCaptor.capture()); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.SCENARIOS_NOT_EMPTY); + assertThat(userIdCaptor.getValue()).isEqualTo(expectedUserId); + assertThat(projectIdCaptor.getValue()).isEqualTo(expectedProjectId); + assertThat(projectStageCaptor.getValue()).isEqualTo(expectedProjectStage); } - @Test - @DisplayName("Make User Story - Valid Request") - void testMakeUserStory_ValidRequest() { - MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); - requestDto.setProjectId("validProjectId"); - requestDto.setScenario(List.of("Scenario 1")); + private void verifyMakeUserstoryUsecase(String expectedUserId, String expectedProjectId, List expectedScenario) { + ArgumentCaptor userIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor projectIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor> scenarioCaptor = ArgumentCaptor.forClass(List.class); + + verify(makeUserstoryUsecase).makeUserstory(userIdCaptor.capture(), projectIdCaptor.capture(), scenarioCaptor.capture()); - Set> violations = validator.validate(requestDto); - assertThat(violations).isEmpty(); + assertThat(userIdCaptor.getValue()).isEqualTo(expectedUserId); + assertThat(projectIdCaptor.getValue()).isEqualTo(expectedProjectId); + assertThat(scenarioCaptor.getValue()).isEqualTo(expectedScenario); } -} \ No newline at end of file +} diff --git a/src/test/java/adaptor/in/web/ProjectControllerValidationTest.java b/src/test/java/adaptor/in/web/ProjectControllerValidationTest.java new file mode 100644 index 0000000..18b457f --- /dev/null +++ b/src/test/java/adaptor/in/web/ProjectControllerValidationTest.java @@ -0,0 +1,336 @@ +package adaptor.in.web; + +import com.syncd.application.port.in.CreateProjectUsecase.*; +import com.syncd.application.port.in.DeleteProjectUsecase.*; +import com.syncd.application.port.in.InviteUserInProjectUsecase.*; +import com.syncd.application.port.in.JoinProjectUsecase.*; +import com.syncd.application.port.in.SyncProjectUsecase.*; +import com.syncd.application.port.in.UpdateProjectUsecase.*; +import com.syncd.application.port.in.WithdrawUserInProjectUsecase.*; +import com.syncd.dto.MakeUserStoryReauestDto; +import com.syncd.exceptions.ValidationMessages; +import jakarta.validation.ConstraintViolation; +import jakarta.validation.Validation; +import jakarta.validation.Validator; +import jakarta.validation.ValidatorFactory; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; + +public class ProjectControllerValidationTest { + + private Validator validator; + + @BeforeEach + void setUp() { + ValidatorFactory factory = Validation.buildDefaultValidatorFactory(); + validator = factory.getValidator(); + } + + // ====================================== + // CreateProject + // ====================================== + + @Test + @DisplayName("Create Project - Invalid Request - Blank Project Name") + void testCreateProject_InvalidRequest_BlankName() { + CreateProjectRequestDto requestDto = new CreateProjectRequestDto("", "description", null, Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.NAME_NOT_BLANK); + } + + @Test + @DisplayName("Create Project - Valid Request - Only Project Name Provided") + void testCreateProject_ValidRequest_OnlyName() { + CreateProjectRequestDto requestDto = new CreateProjectRequestDto("Valid Project", "", null, Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + // ====================================== + // JoinProject + // ====================================== + + @Test + @DisplayName("Join Project - Invalid Request - Blank ProjectId") + void testJoinProject_InvalidRequest_BlankProjectId() { + JoinProjectRequestDto requestDto = new JoinProjectRequestDto(""); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Join Project - Valid Request") + void testJoinProject_ValidRequest() { + JoinProjectRequestDto requestDto = new JoinProjectRequestDto("validProjectId"); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + // ====================================== + // InviteUser + // ====================================== + + @Test + @DisplayName("Invite User - Invalid Request - Blank ProjectId and Empty Users") + void testInviteUser_InvalidRequest_BlankProjectIdAndEmptyUsers() { + InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(2); + + List messages = violations.stream() + .map(ConstraintViolation::getMessage) + .toList(); + + assertThat(messages).contains( + ValidationMessages.PROJECT_ID_NOT_BLANK, + ValidationMessages.USERS_SIZE + ); + } + + @Test + @DisplayName("Invite User - Invalid Request - Blank ProjectId") + void testInviteUser_InvalidRequest_BlankProjectId() { + InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("", List.of("user1@example.com")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Invite User - Invalid Request - Empty Users") + void testInviteUser_InvalidRequest_EmptyUsers() { + InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("validProjectId", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); + } + + @Test + @DisplayName("Invite User - Invalid Request - Less Than 1 User") + void testInviteUser_InvalidRequest_LessThanOneUser() { + InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("validProjectId", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); + } + + @Test + @DisplayName("Invite User - Valid Request") + void testInviteUser_ValidRequest() { + InviteUserInProjectRequestDto requestDto = new InviteUserInProjectRequestDto("validProjectId", List.of("user1@example.com")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + // ====================================== + // WithdrawUser + // ====================================== + + @Test + @DisplayName("Withdraw User - Invalid Request - Blank ProjectId and Empty Users") + void testWithdrawUser_InvalidRequest_BlankProjectIdAndEmptyUsers() { + WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(2); + + List messages = violations.stream() + .map(ConstraintViolation::getMessage) + .toList(); + + assertThat(messages).contains( + ValidationMessages.PROJECT_ID_NOT_BLANK + ); + } + + @Test + @DisplayName("Withdraw User - Invalid Request - Blank ProjectId") + void testWithdrawUser_InvalidRequest_BlankProjectId() { + WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("", List.of("user1@example.com")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Withdraw User - Invalid Request - Empty Users") + void testWithdrawUser_InvalidRequest_EmptyUsers() { + WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("validProjectId", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); + } + + @Test + @DisplayName("Withdraw User - Invalid Request - Less Than 1 User") + void testWithdrawUser_InvalidRequest_LessThanOneUser() { + WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("validProjectId", Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USERS_SIZE); + } + + @Test + @DisplayName("Withdraw User - Valid Request") + void testWithdrawUser_ValidRequest() { + WithdrawUserInProjectRequestDto requestDto = new WithdrawUserInProjectRequestDto("validProjectId", List.of("user1@example.com")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + // ====================================== + // DeleteProject + // ====================================== + + @Test + @DisplayName("Delete Project - Invalid Request - Blank ProjectId") + void testDeleteProject_InvalidRequest_BlankProjectId() { + DeleteProjectRequestDto requestDto = new DeleteProjectRequestDto(""); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Delete Project - Valid Request") + void testDeleteProject_ValidRequest() { + DeleteProjectRequestDto requestDto = new DeleteProjectRequestDto("validProjectId"); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + // ====================================== + // UpdateProject + // ====================================== + + @Test + @DisplayName("Update Project - Invalid Request - Blank ProjectId") + void testUpdateProject_InvalidRequest_BlankProjectId() { + UpdateProjectRequestDto requestDto = new UpdateProjectRequestDto("", "name", "desc", null); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Update Project - Valid Request") + void testUpdateProject_ValidRequest() { + UpdateProjectRequestDto requestDto = new UpdateProjectRequestDto("validProjectId", "newName", "newDesc", null); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + // ====================================== + // SyncProject + // ====================================== + + @Test + @DisplayName("Sync Project - Invalid Request - Blank ProjectId") + void testSyncProject_InvalidRequest_BlankProjectId() { + SyncProjectRequestDto requestDto = new SyncProjectRequestDto("", 10); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Sync Project - Invalid Request - Null Project Stage") + void testSyncProject_InvalidRequest_NullProjectStage() { + SyncProjectRequestDto requestDto = new SyncProjectRequestDto("validProjectId", null); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_PROGRESS_NOT_NULL); + } + + @Test + @DisplayName("Sync Project - Valid Request") + void testSyncProject_ValidRequest() { + SyncProjectRequestDto requestDto = new SyncProjectRequestDto("validProjectId", 10); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } + + // ====================================== + // MakeUserStory + // ====================================== + + @Test + @DisplayName("Make User Story - Invalid Request - Blank ProjectId") + void testMakeUserStory_InvalidRequest_BlankProjectId() { + MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); + requestDto.setProjectId(""); + requestDto.setScenario(List.of("Scenario 1")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.PROJECT_ID_NOT_BLANK); + } + + @Test + @DisplayName("Make User Story - Invalid Request - Null Scenarios") + void testMakeUserStory_InvalidRequest_NullScenarios() { + MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); + requestDto.setProjectId("projectId"); + requestDto.setScenario(null); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(2); + List messages = violations.stream() + .map(ConstraintViolation::getMessage) + .toList(); + assertThat(messages).contains( + ValidationMessages.SCENARIOS_NOT_NULL, + ValidationMessages.SCENARIOS_NOT_EMPTY + ); + } + + @Test + @DisplayName("Make User Story - Invalid Request - Empty Scenarios") + void testMakeUserStory_InvalidRequest_EmptyScenarios() { + MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); + requestDto.setProjectId("projectId"); + requestDto.setScenario(Collections.emptyList()); + + Set> violations = validator.validate(requestDto); + assertThat(violations).hasSize(1); + assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.SCENARIOS_NOT_EMPTY); + } + + @Test + @DisplayName("Make User Story - Valid Request") + void testMakeUserStory_ValidRequest() { + MakeUserStoryReauestDto requestDto = new MakeUserStoryReauestDto(); + requestDto.setProjectId("validProjectId"); + requestDto.setScenario(List.of("Scenario 1")); + + Set> violations = validator.validate(requestDto); + assertThat(violations).isEmpty(); + } +} \ No newline at end of file diff --git a/src/test/java/adaptor/in/web/RoomControllerTest.java b/src/test/java/adaptor/in/web/RoomControllerTest.java index fd05ad2..827bfac 100644 --- a/src/test/java/adaptor/in/web/RoomControllerTest.java +++ b/src/test/java/adaptor/in/web/RoomControllerTest.java @@ -1,27 +1,43 @@ package adaptor.in.web; +import com.syncd.adapter.in.web.RoomController; +import com.syncd.application.port.in.GetAllRoomsByUserIdUsecase; import com.syncd.application.port.in.GetAllRoomsByUserIdUsecase.*; +import com.syncd.application.port.in.GetRoomAuthTokenUsecase; import com.syncd.application.port.in.GetRoomAuthTokenUsecase.*; -import com.syncd.exceptions.ValidationMessages; -import jakarta.validation.Validation; -import jakarta.validation.Validator; -import jakarta.validation.ConstraintViolation; -import jakarta.validation.ValidatorFactory; +import com.syncd.application.service.JwtService; +import jakarta.servlet.http.HttpServletRequest; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; -import java.util.Set; +import java.util.Collections; -import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.*; public class RoomControllerTest { - private Validator validator; + + @Mock + private GetAllRoomsByUserIdUsecase getAllRoomsByUserIdUsecase; + + @Mock + private GetRoomAuthTokenUsecase getRoomAuthTokenUsecase; + + @Mock + private JwtService jwtService; + + @InjectMocks + private RoomController roomController; @BeforeEach - void setUp(){ - ValidatorFactory factory = Validation.buildDefaultValidatorFactory(); - validator = factory.getValidator(); + void setUp() { + MockitoAnnotations.openMocks(this); } // ====================================== @@ -29,22 +45,40 @@ void setUp(){ // ====================================== @Test - @DisplayName("Get Room Auth Token - Invalid Request - Blank RoomId") - void testGetRoomAuthToken_InvalidRequest_BlankRoomId() { - TestDto requestDto = new TestDto(""); + @DisplayName("Get Room Auth Token - Valid Request") + void testGetRoomAuthToken_ValidRequest() { + HttpServletRequest request = mock(HttpServletRequest.class); + setupMockJwtService(request, "token", "userId"); + + GetRoomAuthTokenResponseDto responseDto = new GetRoomAuthTokenResponseDto("authToken"); + when(getRoomAuthTokenUsecase.getRoomAuthToken(anyString())).thenReturn(responseDto); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.ROOM_ID_NOT_BLANK); + GetRoomAuthTokenResponseDto response = roomController.getRoomAuthToken(request); + + assertThat(response).isNotNull(); + assertThat(response.token()).isEqualTo("authToken"); + + verifyJwtServiceInteraction(request, "token"); + verifyGetRoomAuthToken("userId"); } @Test - @DisplayName("Get Room Auth Token - Valid Request") - void testGetRoomAuthToken_ValidRequest() { - TestDto requestDto = new TestDto("validRoomId"); + @DisplayName("Get Room Auth Token - Test - Valid Request") + void testGetRoomAuthTokenTest_ValidRequest() { + HttpServletRequest request = mock(HttpServletRequest.class); + setupMockJwtService(request, "token", "userId"); + + TestDto testDto = new TestDto("validRoomId"); + GetRoomAuthTokenResponseDto responseDto = new GetRoomAuthTokenResponseDto("testAuthToken"); + when(getRoomAuthTokenUsecase.Test(anyString(), anyString())).thenReturn(responseDto); + + GetRoomAuthTokenResponseDto response = roomController.getRoomAuthToken(testDto, request); + + assertThat(response).isNotNull(); + assertThat(response.token()).isEqualTo("testAuthToken"); - Set> violations = validator.validate(requestDto); - assertThat(violations).isEmpty(); + verifyJwtServiceInteraction(request, "token"); + verifyTestRoomAuthToken("userId", "validRoomId"); } // ====================================== @@ -52,22 +86,51 @@ void testGetRoomAuthToken_ValidRequest() { // ====================================== @Test - @DisplayName("Get All Rooms By User Id - Invalid Request - Blank UserId") - void testGetAllRoomsByUserId_InvalidRequest_BlankUserId() { - GetAllRoomsByUserIdRequestDto requestDto = new GetAllRoomsByUserIdRequestDto(""); + @DisplayName("Get All Rooms By User Id - Valid Request") + void testGetAllRoomsByUserId_ValidRequest() { + HttpServletRequest request = mock(HttpServletRequest.class); + setupMockJwtService(request, "token", "userId"); + + GetAllRoomsByUserIdResponseDto responseDto = new GetAllRoomsByUserIdResponseDto("userId", Collections.emptyList()); + when(getAllRoomsByUserIdUsecase.getAllRoomsByUserId(anyString())).thenReturn(responseDto); + + GetAllRoomsByUserIdResponseDto response = roomController.getAllInfoAboutRoomsByUserId(request); - Set> violations = validator.validate(requestDto); - assertThat(violations).hasSize(1); - assertThat(violations.iterator().next().getMessage()).isEqualTo(ValidationMessages.USER_ID_NOT_BLANK); + assertThat(response).isNotNull(); + assertThat(response.userId()).isEqualTo("userId"); + + verifyJwtServiceInteraction(request, "token"); + verifyGetAllRoomsByUserId("userId"); + } + // Helper methods for mock setup + private void setupMockJwtService(HttpServletRequest request, String token, String userId) { + when(jwtService.resolveToken(request)).thenReturn(token); + when(jwtService.getUserIdFromToken(token)).thenReturn(userId); } - @Test - @DisplayName("Get All Rooms By User Id - Valid Request") - void testGetAllRoomsByUserId_ValidRequest() { - GetAllRoomsByUserIdRequestDto requestDto = new GetAllRoomsByUserIdRequestDto("validUserId"); + private void verifyJwtServiceInteraction(HttpServletRequest request, String token) { + verify(jwtService).resolveToken(request); + verify(jwtService).getUserIdFromToken(token); + } + + private void verifyGetRoomAuthToken(String userId) { + ArgumentCaptor userIdCaptor = ArgumentCaptor.forClass(String.class); + verify(getRoomAuthTokenUsecase).getRoomAuthToken(userIdCaptor.capture()); + assertThat(userIdCaptor.getValue()).isEqualTo(userId); + } + + private void verifyGetAllRoomsByUserId(String userId) { + ArgumentCaptor userIdCaptor = ArgumentCaptor.forClass(String.class); + verify(getAllRoomsByUserIdUsecase).getAllRoomsByUserId(userIdCaptor.capture()); + assertThat(userIdCaptor.getValue()).isEqualTo(userId); + } - Set> violations = validator.validate(requestDto); - assertThat(violations).isEmpty(); + private void verifyTestRoomAuthToken(String userId, String roomId) { + ArgumentCaptor userIdCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor roomIdCaptor = ArgumentCaptor.forClass(String.class); + verify(getRoomAuthTokenUsecase).Test(userIdCaptor.capture(), roomIdCaptor.capture()); + assertThat(userIdCaptor.getValue()).isEqualTo(userId); + assertThat(roomIdCaptor.getValue()).isEqualTo(roomId); } } diff --git a/src/test/java/adaptor/in/web/UserControllerTest.java b/src/test/java/adaptor/in/web/UserControllerTest.java new file mode 100644 index 0000000..a0bd25e --- /dev/null +++ b/src/test/java/adaptor/in/web/UserControllerTest.java @@ -0,0 +1,95 @@ +package adaptor.in.web; + +import com.syncd.adapter.in.web.UserController; +import com.syncd.application.port.in.GetUserInfoUsecase; +import com.syncd.application.port.in.GetUserInfoUsecase.GetUserInfoResponseDto; +import com.syncd.application.service.JwtService; +import jakarta.servlet.http.HttpServletRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.Collections; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.*; + +public class UserControllerTest { + + @Mock + private GetUserInfoUsecase getUserInfoUsecase; + + @Mock + private JwtService jwtService; + + @InjectMocks + private UserController userController; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + } + + @Test + @DisplayName("Get User Info - Valid Request") + void testGetUserInfo_ValidRequest() { + String token = "test-token"; + String userId = "user-id"; + + HttpServletRequest request = mock(HttpServletRequest.class); + + when(jwtService.resolveToken(request)).thenReturn(token); + when(jwtService.getUserIdFromToken(token)).thenReturn(userId); + + GetUserInfoResponseDto userInfoResponseDto = new GetUserInfoResponseDto( + "user-id", + "Test User", + "profileImg.jpg", + "test@example.com", + Collections.emptyList() + ); + when(getUserInfoUsecase.getUserInfo(userId)).thenReturn(userInfoResponseDto); + + GetUserInfoResponseDto response = userController.getUserInfo(request); + + assertThat(response).isNotNull(); + assertThat(response.userId()).isEqualTo("user-id"); + assertThat(response.name()).isEqualTo("Test User"); + assertThat(response.img()).isEqualTo("profileImg.jpg"); + assertThat(response.email()).isEqualTo("test@example.com"); + + ArgumentCaptor captor = ArgumentCaptor.forClass(String.class); + verify(getUserInfoUsecase, times(1)).getUserInfo(captor.capture()); + assertThat(captor.getValue()).isEqualTo(userId); + + verify(jwtService, times(1)).resolveToken(request); + verify(jwtService, times(1)).getUserIdFromToken(token); + } + + @Test + @DisplayName("Get User Info - Invalid Token") + void testGetUserInfo_InvalidToken() { + String token = "invalid-token"; + + HttpServletRequest request = mock(HttpServletRequest.class); + + when(jwtService.resolveToken(request)).thenReturn(token); + when(jwtService.getUserIdFromToken(token)).thenThrow(new IllegalArgumentException("Invalid token")); + + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> { + userController.getUserInfo(request); + }); + + assertThat(exception.getMessage()).isEqualTo("Invalid token"); + + verify(jwtService, times(1)).resolveToken(request); + verify(jwtService, times(1)).getUserIdFromToken(token); + verify(getUserInfoUsecase, never()).getUserInfo(anyString()); + } +} From 9a0c38ff7c479e1367272e95438c7e27c17e24ad Mon Sep 17 00:00:00 2001 From: JalJu Date: Sun, 19 May 2024 16:49:49 +0900 Subject: [PATCH 5/7] feat: all done --- src/test/java/mapper/ProjectMapperTest.java | 132 +++++++++----------- src/test/java/mapper/UserMapperTest.java | 106 ++++++++-------- 2 files changed, 107 insertions(+), 131 deletions(-) diff --git a/src/test/java/mapper/ProjectMapperTest.java b/src/test/java/mapper/ProjectMapperTest.java index 7b33383..1f1e9d7 100644 --- a/src/test/java/mapper/ProjectMapperTest.java +++ b/src/test/java/mapper/ProjectMapperTest.java @@ -24,67 +24,40 @@ public class ProjectMapperTest { @BeforeEach void setUp() { - entity1 = new ProjectEntity(); - entity1.setId("id1"); - entity1.setName("Project 1"); - + entity1 = createProjectEntity("id1", "Project 1"); user1 = new UserInProject("user1@example.com", Role.MEMBER); user2 = new UserInProject("user2@example.com", Role.HOST); - - project1 = new Project(); - project1.setId("id1"); - project1.setName("Project 1"); - project1.setDescription("Description 1"); - project1.setUsers(Arrays.asList(user1, user2)); - project1.setProgress(50); - project1.setLastModifiedDate("2022-01-01"); + project1 = createProject("id1", "Project 1", "Description 1", 50, "2022-01-01", user1, user2); } @Test public void testMapProjectEntityToProject() { Project project = projectMapper.mapProjectEntityToProject(entity1); - - assertNotNull(project); - assertEquals("id1", project.getId()); - assertEquals("Project 1", project.getName()); + assertProjectFields(project, "id1", "Project 1"); } @Test public void testMapProjectToProjectEntity() { ProjectEntity entity = projectMapper.mapProjectToProjectEntity(project1); - - assertNotNull(entity); - assertEquals("id1", entity.getId()); - assertEquals("Project 1", entity.getName()); + assertProjectEntityFields(entity, "id1", "Project 1"); } @Test public void testMapProjectEntitiesToProjects() { - ProjectEntity entity2 = new ProjectEntity(); - entity2.setId("id2"); - entity2.setName("Project 2"); - + ProjectEntity entity2 = createProjectEntity("id2", "Project 2"); List entities = Arrays.asList(entity1, entity2); - List projects = projectMapper.mapProjectEntitiesToProjects(entities); assertNotNull(projects); assertEquals(2, projects.size()); - - assertEquals("id1", projects.get(0).getId()); - assertEquals("Project 1", projects.get(0).getName()); - assertEquals("id2", projects.get(1).getId()); - assertEquals("Project 2", projects.get(1).getName()); + assertProjectFields(projects.get(0), "id1", "Project 1"); + assertProjectFields(projects.get(1), "id2", "Project 2"); } @Test public void testMapProjectsToProjectIds() { - Project project2 = new Project(); - project2.setId("id2"); - project2.setName("Project 2"); - + Project project2 = createProject("id2", "Project 2", null, 0, null); List projects = Arrays.asList(project1, project2); - List projectIds = projectMapper.mapProjectsToProjectIds(projects); assertNotNull(projectIds); @@ -96,56 +69,65 @@ public void testMapProjectsToProjectIds() { @Test public void testConvertProjectToProjectForGetAllInfoDto() { ProjectForGetAllInfoAboutRoomsByUserIdResponseDto dto = projectMapper.convertProjectToProjectForGetAllInfoDto("user1@example.com", project1); - - assertNotNull(dto); - assertEquals("id1", dto.id()); - assertEquals("Project 1", dto.name()); - assertEquals("Description 1", dto.description()); - assertEquals(Role.MEMBER, dto.role()); - assertEquals(2, dto.userEmails().size()); - assertTrue(dto.userEmails().contains("user1@example.com")); - assertTrue(dto.userEmails().contains("user2@example.com")); - assertEquals(50, dto.progress()); - assertEquals("2022-01-01", dto.lastModifiedDate()); + assertProjectForGetAllInfoDtoFields(dto, "id1", "Project 1", "Description 1", Role.MEMBER, 50, "2022-01-01", "user1@example.com", "user2@example.com"); } @Test public void testMapProjectsToGetAllRoomsByUserIdResponseDto() { - Project project2 = new Project(); - project2.setId("id2"); - project2.setName("Project 2"); - project2.setDescription("Description 2"); - project2.setUsers(Arrays.asList(user1)); - project2.setProgress(70); - project2.setLastModifiedDate("2022-02-01"); - + Project project2 = createProject("id2", "Project 2", "Description 2", 70, "2022-02-01", user1); List projects = Arrays.asList(project1, project2); - GetAllRoomsByUserIdResponseDto responseDto = projectMapper.mapProjectsToGetAllRoomsByUserIdResponseDto("user1@example.com", projects); assertNotNull(responseDto); assertEquals("user1@example.com", responseDto.userId()); assertEquals(2, responseDto.projects().size()); - ProjectForGetAllInfoAboutRoomsByUserIdResponseDto dto1 = responseDto.projects().get(0); - assertEquals("id1", dto1.id()); - assertEquals("Project 1", dto1.name()); - assertEquals("Description 1", dto1.description()); - assertEquals(Role.MEMBER, dto1.role()); - assertEquals(2, dto1.userEmails().size()); - assertTrue(dto1.userEmails().contains("user1@example.com")); - assertTrue(dto1.userEmails().contains("user2@example.com")); - assertEquals(50, dto1.progress()); - assertEquals("2022-01-01", dto1.lastModifiedDate()); - - ProjectForGetAllInfoAboutRoomsByUserIdResponseDto dto2 = responseDto.projects().get(1); - assertEquals("id2", dto2.id()); - assertEquals("Project 2", dto2.name()); - assertEquals("Description 2", dto2.description()); - assertEquals(Role.MEMBER, dto2.role()); // 기본 역할로 설정됨 - assertEquals(1, dto2.userEmails().size()); - assertTrue(dto2.userEmails().contains("user1@example.com")); - assertEquals(70, dto2.progress()); - assertEquals("2022-02-01", dto2.lastModifiedDate()); + assertProjectForGetAllInfoDtoFields(responseDto.projects().get(0), "id1", "Project 1", "Description 1", Role.MEMBER, 50, "2022-01-01", "user1@example.com", "user2@example.com"); + assertProjectForGetAllInfoDtoFields(responseDto.projects().get(1), "id2", "Project 2", "Description 2", Role.MEMBER, 70, "2022-02-01", "user1@example.com"); + } + + // Helper methods for creating entities and asserting fields + private ProjectEntity createProjectEntity(String id, String name) { + ProjectEntity entity = new ProjectEntity(); + entity.setId(id); + entity.setName(name); + return entity; + } + + private Project createProject(String id, String name, String description, int progress, String lastModifiedDate, UserInProject... users) { + Project project = new Project(); + project.setId(id); + project.setName(name); + project.setDescription(description); + project.setUsers(Arrays.asList(users)); + project.setProgress(progress); + project.setLastModifiedDate(lastModifiedDate); + return project; + } + + private void assertProjectFields(Project project, String id, String name) { + assertNotNull(project); + assertEquals(id, project.getId()); + assertEquals(name, project.getName()); + } + + private void assertProjectEntityFields(ProjectEntity entity, String id, String name) { + assertNotNull(entity); + assertEquals(id, entity.getId()); + assertEquals(name, entity.getName()); + } + + private void assertProjectForGetAllInfoDtoFields(ProjectForGetAllInfoAboutRoomsByUserIdResponseDto dto, String id, String name, String description, Role role, int progress, String lastModifiedDate, String... userEmails) { + assertNotNull(dto); + assertEquals(id, dto.id()); + assertEquals(name, dto.name()); + assertEquals(description, dto.description()); + assertEquals(role, dto.role()); + assertEquals(progress, dto.progress()); + assertEquals(lastModifiedDate, dto.lastModifiedDate()); + assertEquals(userEmails.length, dto.userEmails().size()); + for (String email : userEmails) { + assertTrue(dto.userEmails().contains(email)); + } } } diff --git a/src/test/java/mapper/UserMapperTest.java b/src/test/java/mapper/UserMapperTest.java index b67439a..981d429 100644 --- a/src/test/java/mapper/UserMapperTest.java +++ b/src/test/java/mapper/UserMapperTest.java @@ -17,105 +17,99 @@ import static org.junit.jupiter.api.Assertions.*; public class UserMapperTest { - private final UserMapper userMapper = Mappers.getMapper(UserMapper.class); @Test public void testMapRegisterUserRequestDtoToUser() { RegisterUserRequestDto requestDto = new RegisterUserRequestDto("testUser", "test@example.com", "password"); - User user = userMapper.mapRegisterUserRequestDtoToUser(requestDto); - - assertNotNull(user); - assertEquals("testUser", user.getName()); - assertEquals("test@example.com", user.getEmail()); + assertUserFields(user, "testUser", "test@example.com"); } @Test public void testMapUserToUserForTokenDto() { - User user = new User(); - user.setId("1"); - user.setName("testUser"); - user.setEmail("test@example.com"); - user.setProfileImg("profileImg.jpg"); - + User user = createUser("1", "testUser", "test@example.com", "profileImg.jpg"); UserForTokenDto userForTokenDto = userMapper.mapUserToUserForTokenDto(user); - assertNotNull(userForTokenDto); assertEquals("1", userForTokenDto.userId()); } @Test public void testMapUserEntityToUser() { - UserEntity userEntity = new UserEntity(); - userEntity.setId("1"); - userEntity.setName("testUser"); - userEntity.setEmail("test@example.com"); - userEntity.setProfileImg("profileImg.jpg"); - + UserEntity userEntity = createUserEntity("1", "testUser", "test@example.com", "profileImg.jpg"); User user = userMapper.mapUserEntityToUser(userEntity); - - assertNotNull(user); - assertEquals("1", user.getId()); - assertEquals("testUser", user.getName()); - assertEquals("test@example.com", user.getEmail()); - assertEquals("profileImg.jpg", user.getProfileImg()); + assertUserFields(user, "1", "testUser", "test@example.com", "profileImg.jpg"); } @Test public void testMapUserDtoToUser() { UserDto userDto = new UserDto("1", "test@example.com", "testUser", UserAccountStatus.AVAILABLE, "profileImg.jpg", Arrays.asList("proj1", "proj2")); - User user = userMapper.mapUserDtoToUser(userDto); - - assertNotNull(user); - assertEquals("1", user.getId()); - assertEquals("testUser", user.getName()); - assertEquals("test@example.com", user.getEmail()); - assertEquals("profileImg.jpg", user.getProfileImg()); + assertUserFields(user, "1", "testUser", "test@example.com", "profileImg.jpg"); } @Test public void testMapUserToUserDto() { - User user = new User(); - user.setId("1"); - user.setName("testUser"); - user.setEmail("test@example.com"); - user.setProfileImg("profileImg.jpg"); - + User user = createUser("1", "testUser", "test@example.com", "profileImg.jpg"); UserDto userDto = userMapper.mapUserToUserDto(user); - - assertNotNull(userDto); - assertEquals("1", userDto.id()); - assertEquals("testUser", userDto.name()); - assertEquals("test@example.com", userDto.email()); - assertEquals("profileImg.jpg", userDto.profileImg()); + assertUserDtoFields(userDto, "1", "testUser", "test@example.com", "profileImg.jpg"); } @Test public void testMapUserDtoToUserWithNullProjectIds() { UserDto userDto = new UserDto("1", "test@example.com", "testUser", UserAccountStatus.AVAILABLE, "profileImg.jpg", null); - User user = userMapper.mapUserDtoToUser(userDto); - - assertNotNull(user); - assertEquals("1", user.getId()); - assertEquals("testUser", user.getName()); - assertEquals("test@example.com", user.getEmail()); - assertEquals("profileImg.jpg", user.getProfileImg()); + assertUserFields(user, "1", "testUser", "test@example.com", "profileImg.jpg"); } @Test public void testMapUserToUserRoleDto() { - User user = new User(); - user.setId("1"); - user.setName("testUser"); - + User user = createUser("1", "testUser", null, null); UserRoleDto userRoleDto = userMapper.mapUserToUserRoleDto(user, "proj1", Role.HOST); - assertNotNull(userRoleDto); assertEquals("proj1", userRoleDto.projectId()); assertEquals("1", userRoleDto.userId()); assertEquals(Role.HOST, userRoleDto.role()); } + + // Helper methods to create entities and assert fields + private User createUser(String id, String name, String email, String profileImg) { + User user = new User(); + user.setId(id); + user.setName(name); + user.setEmail(email); + user.setProfileImg(profileImg); + return user; + } + + private UserEntity createUserEntity(String id, String name, String email, String profileImg) { + UserEntity userEntity = new UserEntity(); + userEntity.setId(id); + userEntity.setName(name); + userEntity.setEmail(email); + userEntity.setProfileImg(profileImg); + return userEntity; + } + + private void assertUserFields(User user, String id, String name, String email, String profileImg) { + assertNotNull(user); + assertEquals(id, user.getId()); + assertEquals(name, user.getName()); + assertEquals(email, user.getEmail()); + assertEquals(profileImg, user.getProfileImg()); + } + + private void assertUserFields(User user, String name, String email) { + assertNotNull(user); + assertEquals(name, user.getName()); + assertEquals(email, user.getEmail()); + } + + private void assertUserDtoFields(UserDto userDto, String id, String name, String email, String profileImg) { + assertNotNull(userDto); + assertEquals(id, userDto.id()); + assertEquals(name, userDto.name()); + assertEquals(email, userDto.email()); + assertEquals(profileImg, userDto.profileImg()); + } } From b3c33c13bb759ac18f2e0f4954b12c763487b633 Mon Sep 17 00:00:00 2001 From: JalJu Date: Sun, 19 May 2024 16:50:54 +0900 Subject: [PATCH 6/7] feat: all done --- src/test/java/mapper/ProjectMapperTest.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test/java/mapper/ProjectMapperTest.java b/src/test/java/mapper/ProjectMapperTest.java index 1f1e9d7..180c8a2 100644 --- a/src/test/java/mapper/ProjectMapperTest.java +++ b/src/test/java/mapper/ProjectMapperTest.java @@ -86,7 +86,6 @@ public void testMapProjectsToGetAllRoomsByUserIdResponseDto() { assertProjectForGetAllInfoDtoFields(responseDto.projects().get(1), "id2", "Project 2", "Description 2", Role.MEMBER, 70, "2022-02-01", "user1@example.com"); } - // Helper methods for creating entities and asserting fields private ProjectEntity createProjectEntity(String id, String name) { ProjectEntity entity = new ProjectEntity(); entity.setId(id); From 8041fa614c365c6b807f7a9a2cfa32b9f2a583d6 Mon Sep 17 00:00:00 2001 From: JalJu Date: Sun, 19 May 2024 16:52:18 +0900 Subject: [PATCH 7/7] feat: all done --- src/test/java/application/port/in/DeleteProjectUsecaseTest.java | 1 + .../application/port/in/InviteUserInProjectUsecaseTest.java | 2 ++ src/test/java/application/port/in/UpdateProjectUsecaseTest.java | 2 ++ 3 files changed, 5 insertions(+) diff --git a/src/test/java/application/port/in/DeleteProjectUsecaseTest.java b/src/test/java/application/port/in/DeleteProjectUsecaseTest.java index 1d1af68..d304d77 100644 --- a/src/test/java/application/port/in/DeleteProjectUsecaseTest.java +++ b/src/test/java/application/port/in/DeleteProjectUsecaseTest.java @@ -28,6 +28,7 @@ void testDeleteProject(){ DeleteProjectResponseDto actualResponse = deleteProjectUsecase.deleteProject(userId, projectId); assertEquals(expectedResponse.projectId(), actualResponse.projectId(), "ProjectID와 삭제된 ProjectID가 불일치합니다."); } + @Test @DisplayName("Throw exception when project does not exist") void testDeleteNonExistingProject() { diff --git a/src/test/java/application/port/in/InviteUserInProjectUsecaseTest.java b/src/test/java/application/port/in/InviteUserInProjectUsecaseTest.java index e939859..726a748 100644 --- a/src/test/java/application/port/in/InviteUserInProjectUsecaseTest.java +++ b/src/test/java/application/port/in/InviteUserInProjectUsecaseTest.java @@ -23,6 +23,7 @@ public class InviteUserInProjectUsecaseTest { private InviteUserInProjectUsecase inviteUserInProjectUsecase; String userId = "user123"; List users = List.of("user234", "user345"); + @Test void testInviteUserInProject(){ String projectId = "project456"; @@ -33,6 +34,7 @@ void testInviteUserInProject(){ assertEquals(expectedResponse.projectId(), actualResponse.projectId()); verify(inviteUserInProjectUsecase).inviteUserInProject(userId, projectId, users); } + @Test @DisplayName("Project 초대 시 존재하지 않는 Project에 대한 예외 처리") void testInviteUserInNonExistingProject() { diff --git a/src/test/java/application/port/in/UpdateProjectUsecaseTest.java b/src/test/java/application/port/in/UpdateProjectUsecaseTest.java index f5bab43..1a2aa21 100644 --- a/src/test/java/application/port/in/UpdateProjectUsecaseTest.java +++ b/src/test/java/application/port/in/UpdateProjectUsecaseTest.java @@ -21,6 +21,7 @@ public class UpdateProjectUsecaseTest { String projectName = "공감대"; String description = "이해하지마 공감해"; String image = "updated_image.jpg"; + @Test @DisplayName("ProjectID를 기반으로 Project 정보 업데이트 테스트") void testUpdateProject(){ @@ -35,6 +36,7 @@ void testUpdateProject(){ assertEquals(expectedResponse.projectId(), actualResponse.projectId()); verify(updateProjectUsecase).updateProject(userId, projectId, projectName, description, image); } + @Test @DisplayName("Project 업데이트 시 존재하지 않는 프로젝트에 대한 예외 처리") void testUpdateNonExistingProject() {