TACO 프로젝트 회고록(2023-04-19)

2023-04-19 수

오늘은 로그인 기능에 대한 테스트를 진행해보았다.

로그인 기능은 사용장의 데이터와 밀접한 관련이 있다.

그중 UserRepository에 대한 테스트를 진행해보았다.

오늘 공부하고 코드를 작성하면서 하나 또 좋은 것을 배웠다.

내가 사용하는 레파지토리의 부모 객체인 JpaRepository의 메서드 중 exists 메서드를 알게 되었다.

이 부분은 해당 테스트를 얘기하면서 설명하겠다.

---

레파지토리의 유무 테스트

    @Test
    void 레파지토리isNotNull(){
        Assertions.assertThat(userRepository).isNotNull();
    }

가장 먼저 해당 레파지토리의 유무를 파악하는 테스트를 진행했다.

이 테스트를 성공시키기 위해서는 해당 테스트 클래스의 의존성을 주입한 UserRepository가 필요하다.

@Repository
public interface UserRepository extends JpaRepository<UserEntity, Long> {

}

이 레파지토리를 만든 후 실행 시키니 성공하였다.

회원가입(아이디 중복) 테스트

    // 회원가입 - 아이디 중복
    @Test
    @Transactional
    void signUp_duplicateId(){
        //when
        UserEntity user1 = UserEntity.builder()
        .userId("yhw0104")
        .userPassword("1234")
        .userName("윤현우")
        .userNickName("닉네임1")
        .build();

        UserEntity user2 = UserEntity.builder()
        .userId("yhw0104")
        .userPassword("5678")
        .userName("윤형우")
        .userNickName("닉네임2")
        .build();
        
        userRepository.save(user1);

        //given
        String user2Id = user2.getUserId();
        boolean dupId = userRepository.existsByUserId(user2Id);

        if(dupId == true){
            log.info("duplicate Id!!");
        }
        if(dupId == false) {
            userRepository.save(user2);
            log.info("create Id!!");
        }
        //then

        Assertions.assertThat(userRepository.findById(2L)).isEmpty();
    }

회원 가입을 하기 위해서는 중복되는 아이디와 닉네임이 있으면 안된다.

그 중, 중복되는 아이디를 가입하려고 할 때의 테스트를 진행했다.

가장 먼저 이미 등록되어 있는 회원을 만들고, 새로 등록하려는 회원의 아이디가 같을 때의 상황이다.

//given의 값이 회원 가입 창에서 "아이디 확인" 버튼을 눌렀을 때의 코드이다.

사용자가 원하는 아이디 값을 입력하고 중복 체크를 할 때 userRepository에서 해당하는 같은 값이 있는지 찾은 후 boolean타입으로 반환한다.

@Repository
public interface UserRepository extends JpaRepository<UserEntity, Long> {

    // 닉네임 중복 검사
    boolean existsByUserNickName(String userNickName);

}

여기서 JpaRepository의 새로운 메서드인 existsBy~~ 메서드를 알게 된 것이다.

existsBy~ 메서드는 파라미터로 받아온 값을 By뒤의 데이터베이스 안의 모든 엔티티 값과 비교하여 같은 것이 있는지 확인하는 메서드이다.

이를 통해 만약 반환 값이 참이면 중복되는 값이 있는 것이고, 반환 값이 거짓이면 중복되지 않는 것을 알 수 있다.

나는 이를 디버깅하며 확인하고 싶어 log를 사용하였다.

그렇게 해서 //then에서는 결국 아이디 값이 같기 때문에 2번째 회원이 없다는 것을 확인하게 해준다.

회원가입(닉네임 중복) 테스트

    // 회원가입 - 닉네임 중복
    @Test
    @Transactional
    void singUp_duplicateNickName(){
        //when
        UserEntity user1 = UserEntity.builder()
        .userId("yhw0104")
        .userPassword("1234")
        .userName("윤현우")
        .userNickName("같은 닉네임")
        .build();

        UserEntity user2 = UserEntity.builder()
        .userId("0104yhw")
        .userPassword("5678")
        .userName("윤현웅")
        .userNickName("같은 닉네임")
        .build();
        
        userRepository.save(user1);

        //given
        String user2NickName = user2.getUserNickName();
        boolean dupNickName = userRepository.existsByUserNickName(user2NickName);

        if(dupNickName == true){
            log.info("duplicate NickName!!");
        }
        if(dupNickName == false) {
            userRepository.save(user2);
            log.info("create NickName!!");
        }

        //then
        Assertions.assertThat(userRepository.findById(2L)).isEmpty();
    }

이 테스트도 아이디 중복 테스트와 같기 때문에 바로 넘어가겠다.

@Repository
public interface UserRepository extends JpaRepository<UserEntity, Long> {

    // 닉네임 중복 검사
    boolean existsByUserNickName(String userNickName);

    // 아이디 중복 검사
    boolean existsByUserId(String userId);
}

회원가입 성공 테스트

    // 회원가입 - 성공
    @Test
    @Transactional
    void signUp_Success(){
        //when
        UserEntity user1 = UserEntity.builder()
        .userId("yhw0104")
        .userPassword("1234")
        .userName("윤현우")
        .userNickName("닉네임1")
        .build();

        UserEntity user2 = UserEntity.builder()
        .userId("0104yhw")
        .userPassword("5678")
        .userName("윤현웅")
        .userNickName("닉네임2")
        .build();
        
        userRepository.save(user1);

        //given
        String user2Id = user2.getUserId();
        String user2NickName = user2.getUserNickName();

        boolean dupUserId = userRepository.existsByUserId(user2Id);
        boolean dupUserNickName = userRepository.existsByUserNickName(user2NickName);

        if(dupUserId == false){
            if(dupUserNickName == false){
                userRepository.save(user2);
                log.info("save User!!");
            }
        }


        //then
        List<UserEntity> list = userRepository.findAll();
        Assertions.assertThat(list.size()).isEqualTo(2);

    }

해당 테스트는 아이디와 닉네임이 중복되지 않아 회원가입에 성공하게되는 테스트이다.

이때 아이디 중복 체크와 닉네임 중복 체크를 모두 성공했기 때문에 2번째 회원 가입이 성공하게 되고 테스트는 해당 데이터들의 size를 통해 2이면 성공하는 방법으로 테스트 했다.

(2번째 회원도 회원가입에 성공했기 때문에 데이터 베이스의 2명의 회원이 등록되어 있어야 하기 때문이다.)

아이디 찾기(이름과 전화번호로) 테스트

    // 아이디 찾기 (이름과 전화번호로)
    @Test
    @Transactional
    void findUserId(){
        //when
        UserEntity user1 = UserEntity.builder()
        .userId("yhw0104")
        .userPassword("1234")
        .userName("윤현우")
        .userNickName("닉네임1")
        .userPhoneNumber("01062635367")
        .build();

        userRepository.save(user1);

        //given
        String user1Name = user1.getUserName();
        String user1PhoneNumber = user1.getUserPhoneNumber();

        Optional<UserEntity> findId = userRepository.findByUserNameAndUserPhoneNumber(user1Name, user1PhoneNumber);
        
        String findUserId = findId.get().getUserId();
        //then
        Assertions.assertThat(user1.getUserId()).isEqualTo(findUserId);
    }

이 테스트는 아이디나 비밀번호를 까먹었을 때 아이디를 찾기위한 테스트이다.

내가 만들고자 하는 웹페이지에서는 이름과 전화번호를 알면 아이디를 찾을 수 있게 할 것이다.

그래서 이름과 전화번호 값을 받아오면 해당하는 회원의 아이디를 반환하는 테스트이다.

여기서도 JpaRepository의 findBy~ 메서드를 사용하여 해당하는 데이터를 찾고 그 데이터의 아이디를 .get()메서드로 받아와 반환하도록 만들었다.

@Repository
public interface UserRepository extends JpaRepository<UserEntity, Long> {

    // 닉네임 중복 검사
    boolean existsByUserNickName(String userNickName);

    // 아이디 중복 검사
    boolean existsByUserId(String userId);

    //아이디 찾기 (이름과 전화번호로)
    Optional<UserEntity> findByUserNameAndUserPhoneNumber(String userName, String userPhoneNumber);
}

비밀번호 찾기 및 변경 (아이디와 이름으로) 테스트

    // 비밀번호 찾기 및 변경 (아이디와 이름으로)
    @Test
    @Transactional
    void findUserPassword(){
        //when
        UserEntity user1 = UserEntity.builder()
        .userId("yhw0104")
        .userPassword("1234")
        .userName("윤현우")
        .userNickName("닉네임1")
        .userPhoneNumber("01062635367")
        .build();

        UserEntity user = userRepository.save(user1);

        //given
        String userId = user1.getUserId();
        String userName = user1.getUserName();

        Optional<UserEntity> findPassword = userRepository.findByUserIdAndUserName(userId, userName);
        
        String changePassword = "5678";

        findPassword.map(p -> {
            findPassword.get().setUserPassword(changePassword);

            return p;
        })
            .map(p -> userRepository.save(p));

        
        //then
        assertThat(user.getUserId()).isEqualTo(user1.getUserId());
        assertThat(user.getUserName()).isEqualTo(user1.getUserName());
        assertThat(user.getUserNickName()).isEqualTo(user1.getUserNickName());
        assertThat(user.getUserPhoneNumber()).isEqualTo(user1.getUserPhoneNumber());
        assertThat(user.getUserPassword()).isEqualTo(changePassword);

    }

해당 테스트도 아이디 찾기 테스트와 비슷하게 findBy~ 메서드를 통해 가져온 데이터의 비밀번호를 변경하는 테스트이다.

비밀번호는 Optional의 map메서드를 사용해서 수정하였다.

회원정보 보기 (설정) 테스트

    // 회원정보 보기
    @Test
    @Transactional
    void getUserInfo() {
        // when
        UserEntity user1 = UserEntity.builder()
        .userId("yhw0104")
        .userPassword("1234")
        .userName("윤현우")
        .userNickName("닉네임1")
        .userPhoneNumber("01062635367")
        .build();

        UserEntity user = userRepository.save(user1);

        //given
        Optional<UserEntity> expected = userRepository.findById(1L);
        
        //then
        assertThat(1L).isEqualTo(expected.get().getUserIndex());
        assertThat(user.getUserId()).isEqualTo(expected.get().getUserId());
        assertThat(user.getUserName()).isEqualTo(expected.get().getUserName());
        assertThat(user.getUserNickName()).isEqualTo(expected.get().getUserNickName());
        assertThat(user.getUserPhoneNumber()).isEqualTo(expected.get().getUserPhoneNumber());
    }

해당 테스트는 회원 정보를 수정하기 전에 볼 수 있는 페이지에 대한 테스트이다.

이 테스트는 게시글 상세정보 테스트와 같기 때문에 설명은 하지 않겠다.

회원정보 수정 테스트

    // 회원정보 수정
    @Test
    @Transactional
    void updateUserInfo(){
        //when
        UserEntity user1 = UserEntity.builder()
        .userId("yhw0104")
        .userPassword("1234")
        .userName("윤현우")
        .userNickName("닉네임1")
        .userPhoneNumber("01062635367")
        .build();

        UserEntity user = userRepository.save(user1);
        //given
        Optional<UserEntity> expected = userRepository.findById(1L);

        expected.map(p -> {
            expected.get().setUserName("윤하연");
            expected.get().setUserNickName("윤공주");
            expected.get().setUserPhoneNumber("01092595367");
        
            return p;
        })
        .map(p -> userRepository.save(p));

        //then
        assertThat(1L).isEqualTo(expected.get().getUserIndex());
        assertThat(user.getUserId()).isEqualTo(expected.get().getUserId());
        assertThat(user.getUserPassword()).isEqualTo(expected.get().getUserPassword());
        assertThat(expected.get().getUserName()).isEqualTo("윤하연");
        assertThat(expected.get().getUserNickName()).isEqualTo("윤공주");
        assertThat(expected.get().getUserPhoneNumber()).isEqualTo("01092595367");

    }

해당 테스트는 회원정보를 수정하는 테스트이다.

여기서도 Optional map메서드를 이용하여 바꾸었다.

아이디와 비밀번호는 변경할 수 없도록 만들 것이다.

회원 탈퇴 테스트

    // 회원 탈퇴
    @Test
    @Transactional
    void deleteUserInfo(){
        //when
        UserEntity user1 = UserEntity.builder()
        .userId("yhw0104")
        .userPassword("1234")
        .userName("윤현우")
        .userNickName("닉네임1")
        .userPhoneNumber("01062635367")
        .build();

        userRepository.save(user1);
        //given
        userRepository.deleteById(1L);

        //then
        assertThat(userRepository.findById(1L)).isEmpty();
    }

회원 탈퇴시 테스트이다.

여기서도 게시글 삭제 테스트와 똑같이 JpaRepository의 deleteById()메서드로 해당 PK의 데이터를 삭제하는 테스트이다.

---

어제는 로그인 기능에 대한 테스트 주제를 생각해보았고, 오늘은 생각한 테스트들을 작성하고 실행하는 시간을 가졌다.

테스트는 만들기 쉬웠다.

다만 아직 세션에 대한 공부를 통해 실제 로그인 기능을 구현할 수 있을지가 걱정이다.

여기저기 구글링도 하기도 하고, 저번에 하다가 중도에 무산이된 프로젝트 코드도 보면서 열심히 공부해서 꼭 기능을 구현하고 싶다.

하지만 이것보다 걱정인 것이 하나 있다.

사실 백엔드 작업을 하는 인원이 나밖에 없어서 코드리뷰를 할 수 없고, 코드리뷰를 하지 않으니 내가 제대로 하고있는 것도 잘 모르겠는 생각이 든다.

많은 기능을 공부하고 구현해보고 싶어 혼자 한 것이지만, 잘 하고 있는지 모르겠을 때는 혼자하는 것을 후회하기도 한다.

그래도 어쩌겠나. 내가 선택한 것이니 내가 잘 이끌어 나가야지 하하

아무튼 오늘도 공부가 잘되어 뿌듯한 하루였다.

내일도 빡코딩 해야지!!