Fortunetoss

@Test
@DisplayName("일반로그인_토큰발급성공")
void 로그인_성공() throws Exception {
    JoinDTO joinDTO = new JoinDTO("goorm94@naver.com", "password1234&");
    String loginRequest = objectMapper.writeValueAsString(joinDTO);

    MvcResult result = mockMvc.perform(post("/login")
                    .contentType(MediaType.APPLICATION_JSON)
                    .content(loginRequest))
            .andExpect(cookie().exists("refresh"))
            .andExpect(header().exists("access"))
            .andExpect(status().isOk())
            .andReturn();

    String accessToken = result.getResponse().getHeader("access");
    String refreshToken = result.getResponse().getCookie("refresh").getValue();
    
    assertNotNull(accessToken);
    assertNotNull(refreshToken);
    assertEquals(joinDTO.getUsername(), jwtUtil.getUsername(accessToken));
}

/**
 *  Many 기준 조회로 페이징이 가능
 *  LuckyPouch → Shape, QuestionCustom 은 모두 단일 참조 관계
 *  fetch join 을 사용해 연관된 데이터를 즉시 로딩 (N+1 방지)
 *  페이징(offset + limit) 은 중복 데이터 뻥튀기 없음
 */

public Slice<LuckyPouch> findUsersLuckyPouches(User findUser, Pageable pageable) {
    List<LuckyPouch> luckyPouches = queryFactory.select(luckyPouch)
        .from(luckyPouch)
        .join(luckyPouch.shape, shape).fetchJoin()
        .leftJoin(luckyPouch.questionCustom).fetchJoin()
        .where(luckyPouch.user.eq(findUser))
        .offset(pageable.getOffset())
        .limit(pageable.getPageSize() + 1)
        .orderBy(
            questionCustomIsNotNullDesc(),
            luckyPouch.questionCustom.createdAt.desc()
        )
        .fetch();

    boolean hasNext = luckyPouches.size() > pageable.getPageSize();
    if (hasNext) luckyPouches.remove(pageable.getPageSize());

    return new SliceImpl<>(luckyPouches, pageable, hasNext);
}

private OrderSpecifier<Integer> questionCustomIsNotNullDesc() {
    return new CaseBuilder()
        .when(luckyPouch.questionCustom.isNotNull()).then(1)
        .otherwise(0)
        .desc();
}

  public Question findRandomQuestion(User findUser){
        Question findQuestion = queryFactory.select(question)
                .from(question)
                .where(question.id.notIn(
                        queryFactory.select(pouch.question.id)
                                .from(pouch)
                                .join(pouch.user, user)
                                .where(user.eq(findUser))
                ))
                .limit(1)
                .fetchOne();



        return findQuestion;

    }

//  커스텀 애너테이션 정의
@Constraint(validatedBy = NicknameValidator.class)
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Nickname {
  String message() default "닉네임은 10자 이내, 특수문자·띄어쓰기·이모지 불가";
  Class<?>[] groups() default {};
  Class<? extends Payload>[] payload() default {}; 
}


//  Validator 구현
public class NicknameValidator implements ConstraintValidator<Nickname, String> {
    //         조건: 10자 이내, 특수문자/띄어쓰기/이모지 포함 금지
    private static final String PATTERN = "^[a-zA-Z0-9ㄱ-ㅎㅏ-ㅣ가-힣]{1,10}$";
    @Override
    public boolean isValid(String nickname, ConstraintValidatorContext context) {
        return nickname != null && nickname.matches(PATTERN);
    }
}



//  DTO + 컨트롤러 적용


public class NicknameRequest {

    @NotNull(message = "닉네임은 필수 입력 값입니다.") // 추가
    @Nickname
    private String nickname;
}


@PostMapping("/users/validate")
public ResponseEntity<ResponseDto<?>> validateUser(@Valid @RequestBody NicknameRequest request) {

    return new ResponseEntity<>(
        new ResponseDto<>("success", "user validate success", null, null, 200),
        HttpStatus.OK);
}

@Component
@RequiredArgsConstructor
public class ShapeInitializer {
    private final ShapeRepository shapeRepository;

    @PostConstruct
    public void init() {
        if (shapeRepository.count() == 0) {
            List<String> shapes = List.of("A", "B", "C", "D", "E", "F", "G", "H");
            shapes.forEach(s -> shapeRepository.save(Shape.builder().domain(s).build()));
            System.out.println("Shape 데이터 초기화 완료");
        }
    }
}

@Transactional
public void deleteUser() {
    User currentUser = getCurrentUser();

    pouchRepository.deleteByUserId(currentUser.getId());

    luckyPouchRepository.findByUserId(currentUser.getId()).forEach(pouch -> {
        if (pouch.getQuestionCustom() != null) {
            luckyPouchRepository.delete(pouch);
            answerRepository.deleteByQuestionCustomId(pouch.getQuestionCustom().getId());
            questionCustomRepository.deleteById(pouch.getQuestionCustom().getId());
        }
    });

    luckyPouchRepository.deleteByUserId(currentUser.getId());
    userRepository.delete(currentUser);
}