[우아한테크코스] 5기 백엔드 2주차 프리코스 회고록

- 벌써 2주차 마무리...? 시간이 너무 빨라서 믿기지 않는다. 오늘 하루 회고랑 함께 쉬면서 다시 3주차 달릴 준비해야지...😵‍💫

 

| 1주차 회고록

[우아한테크코스] 5기 백엔드 1주차 프리코스 회고록

 

| 2주차 코드

GitHub - Cl8D/java-baseball: 숫자 야구 게임 미션을 진행하는 저장소

- 아무나 코드 리뷰... 해주시면 좋겠다... 👀

 

- 다소 지루할 수 있는 회고록을 환기시키는 재밌는 이미지.

 

---

| 2주차 커밋 기록 살펴보기

- 2주차는 1주차에 비해서 커밋을 가볍게 가져가려고 노력했다.

'기능 단위의 커밋'을 하려고 하다 보니까 오히려 한 번 커밋할 때 더 신중하게 해서 그런지 뒤늦게 수정할 일이 별로 없었다.

- 사실 과제 시작할 때마다 늘 고민한다. 아... 이거 그냥 한글로 쓸까?

가끔 파파고를 돌리면서까지 영어로 커밋하는 내가 너무 싫지만... 역시 영어로 쓰는 게 멋있다.

- 하지만 아쉬우니까 body에는 한글로 썼다. 부족한 영어 커밋을 채워주는 한글 메시지라고 생각하면서 커밋 중...

- 또! 다짜고짜 푸시하는 습관을 버렸다. 이번 과제 때는 마감 때 한 번에 푸시를 날렸다...

원격 저장소에 올라간 건 수정할 수 없다는 걸 늘 명심하고 명심할 것.

 

---

| 패키지 구조

- 2주차는 하나의 '숫자 야구 게임' 이라는 큰 주제 안에서 작성한 코드여서 패키지 분리부터 고민을 시작했다.

- 사실 4기 백엔드 지원자분들의 코드 패턴도 구경했었는데, MVC 구조를 채택하신 분이 많아서 잠깐 고민했다.

하지만...! MVC 보다는 조금 더 자바 프로그래밍다운 코드를 짜고 싶었고, 무엇보다 컨트롤러와 모델 정의가 조금 까다로울 것 같아 그냥 패스.

- 결과적으로는 상수 패키지, 유틸 패키지, 검증 패키지, 메인 패키지로 나누었다.

BaseballGame 클래스도 세분화시켜서 나눌지 말지 엄청 고민하다가... '야구 게임'을 진행하는 하나의 클래스라는 생각이 들어서 그냥 그대로 두었다.

아마 상수 / 유틸 / 검증은 다음 과제에서도 그대로 사용하지 않을까 싶다.

---

| 초기 설계 코드 

- 초기에 문제를 보고 별도의 분리 작업 없이 한번에 작성한 코드이다. 

package baseball;

        import camp.nextstep.edu.missionutils.Console;
        import camp.nextstep.edu.missionutils.Randoms;

        import java.util.ArrayList;
        import java.util.List;
        import java.util.Objects;

public class Application {
    public static void main(String[] args) {
        System.out.println("숫자 야구 게임을 시작합니다.");
        String restart = "1";
        // TODO 변수 이름 체크
        // TODO 메서드 분리

        while (restart.equals("1")) {
            // 1~9까지의 숫자로 이루어진 3글자 만들기
            // 서로 다른 수로 이루어져 있다는 것이 특징
            List<Integer> computer = new ArrayList<>();

            while (computer.size() < 3) {
                int randomNumber = Randoms.pickNumberInRange(1, 9);
                if (!computer.contains(randomNumber)) {
                    computer.add(randomNumber);
                }
            }

            // 같은 수가 아예 없음 = 낫싱
            List<Integer> userNum;

            while (true) {
                userNum = new ArrayList<>();
                int strike = 0, ball = 0;

                System.out.print("숫자를 입력해주세요 : ");
                // TODO 사용자가 3글자가 아닌 수를 입력했을 때 체크 -> 예외 사항 발생
                String[] input = Console.readLine().split("");

                if (input.length != 3) {
                    throw new IllegalArgumentException("3글자 입력하세요");
                }

                // TODO 꼭 이런 식으로 넣는 게 맞나...?
                for (String s : input) {
                    if(!userNum.contains(Integer.parseInt(s))) {
                        userNum.add(Integer.parseInt(s));
                    }
                }

                if (userNum.size() != 3) {
                    throw new IllegalArgumentException("서로 다른 3글자를 입력하세요.");
                }

                // TODO 숫자는 상수화 필요 (굳이 이렇게 반복문 돌아야 되는지 체크)
                for (int i = 0; i < 3; i++) {
                    // 같은 수가 같은 자리 = 스트라이크
                    if (Objects.equals(computer.get(i), userNum.get(i))) {
                        strike++;
                        continue;
                    }
                    // 같은 수가 다른 자리 = 볼
                    if (computer.contains(userNum.get(i))) {
                        ball++;
                    }
                }

                // 결과 안내하는 메서드
                StringBuilder answer = new StringBuilder("");
                if (ball == 0 && strike == 0) {
                    System.out.println("낫싱");
                    continue;
                }
                if (ball != 0) {
                    answer.append(ball).append("볼 ");
                }
                if (strike != 0) {
                    answer.append(strike).append("스트라이크");
                }
                System.out.println(answer.toString().trim());

                if (strike == 3) {
                    System.out.println("3개의 숫자를 모두 맞히셨습니다! 게임 종료");
                    System.out.println("게임을 새로 시작하려면 1, 종료하려면 2를 입력하세요.");
                    restart = Console.readLine();
                    break;
                }
            }
        }
    }
}

- 사실 기능이 어려운 건 아니어서 코드 짜는 건 정말 얼마 안 걸렸다. 30분?

다만... 마지막에 무한으로 증식한 } << 이 친구를 보면 정말 참을 수가 없다. 이 상태로 우테코 제출했으면 아마 끝장이겠지... 

그래도 이렇게 초기 설계 진행하면서 체크해야 되는 부분 찾고, 그 뒤로 조금 더 구체적으로 리팩토링을 하다 보면 기능 분리가 쉬워진다.

하지만! 이제는 이렇게 초기 코드 없이, 3주차부터는 바로 기능 명세 작성 > 코드 구현 구조로 5시간 내에 끝내볼 예정이다. 파이널처럼!

 

---

| MessageConst / NumberConst

- 말 그대로 상수를 관리하는 클래스이다. 하나는 메시지, 하나는 숫자 관련.

package baseball.constant;

/**
 * 메시지 관련 상수 관리 클래스
 */
public final class MessageConst {

    public static final String START_GAME_MSG = "숫자 야구 게임을 시작합니다.";

    public static final String INPUT_MSG = "숫자를 입력해주세요 : ";

    public static final String BALL = "볼";

    public static final String STRIKE = "스트라이크";

    public static final String NOTHING = "낫싱";

    public static final String SUCCESS_MSG = NumberConst.INPUT_LENGTH + "개의 숫자를 모두 맞히셨습니다! 게임 종료";

    public static final String GAME_CONTROL_MSG = "게임을 새로 시작하려면 " + NumberConst.RESTART_NUM +
            ", 종료하려면 " + NumberConst.EXIT_NUM + "를 입력하세요.";

    public static final String INPUT_LENGTH_EXCEPTION_MSG = NumberConst.INPUT_LENGTH + "글자를 입력해 주세요.";

    public static final String INPUT_RANGE_EXCEPTION_MSG = NumberConst.FIRST_RANGE + "~" +
            NumberConst.LAST_RANGE + " 사이의 값을 입력해 주세요.";

    public static final String INPUT_DUPLICATE_EXCEPTION_MSG = "중복된 숫자는 입력할 수 없습니다.";

    public static final String GAME_CONTROL_EXCEPTION_MSG = NumberConst.RESTART_NUM + "(재시작) 혹은 " +
            NumberConst.EXIT_NUM + "(종료)를 입력해 주세요.";
}

package baseball.constant;

/**
 * 숫자 관련 상수 관리 클래스
 */
public final class NumberConst {

    public static final Integer RESTART_NUM = 1;

    public static final Integer EXIT_NUM = 2;

    public static final Integer INPUT_LENGTH = 3;

    public static final Integer FIRST_RANGE = 1;

    public static final Integer LAST_RANGE = 9;

    public static final Integer MAX_STRIKE = 3;
}

- 처음 구현했을 때는 내부만 static final로 지정해두고 클래스까지는 안 했는데, 어차피 상수 관리 클래스면 final로 관리하는 게 좋을 것 같아서 변경했다.

다음에는 enum을 사용해볼까 생각 중! 확실히 숫자나 메시지는 상수로 관리해두는 게 깔끔해서 좋은 것 같다.

---

| ComputerUtil

- 컴퓨터가 하는 일을 관리하는 클래스. 사실 이 부분은 예제 코드를 그대로 사용했다.

package baseball.util;

        import camp.nextstep.edu.missionutils.Randoms;

        import java.util.ArrayList;
        import java.util.List;

/**
 * 컴퓨터 측에서 사용되는 유틸 클래스
 */
public class ComputerUtil {

    /**
     * 컴퓨터가 사용할 3자리 숫자를 만들어내는 메서드
     */
    public List<Integer> generateNumber() {
        List<Integer> computerNums = new ArrayList<>();

        while (computerNums.size() < 3) {
            int randomNum = Randoms.pickNumberInRange(1, 9);
            if (!computerNums.contains(randomNum)) {
                computerNums.add(randomNum);
            }
        }

        return computerNums;
    }
}

- 여기서 코드 제한을 건 이유가 사실 궁금했었는데, 테스트 코드를 보면서 그게 말끔히 해결됐다. 이건 후술할 예정!

---

| UserUtil

- 사용자가 하는 일을 관리하는 클래스. 여기도 미션에서 주어진대로 사용했다.

package baseball.util;

        import camp.nextstep.edu.missionutils.Console;

/**
 * 사용자 측에서 사용되는 유틸 클래스
 */
public class UserUtil {

    /**
     * 사용자로부터 값을 입력받는 메서드
     */
    public String getInputNumber() {
        return Console.readLine();
    }
}

- 사실 이쯤 오니까 굳이 이걸 분리했어야 됐나? 싶은 부분도 있지만...! 앞으로 미션이 더 커진다면 묶을 범위도 더 커지지 않을까...

---

| MessageUtil

- 메시지와 관련된 일을 담당하는 유틸 클래스이다. 메시지 출력에 관한 부분을 여기에 담았다.

package baseball.util;

        import static baseball.constant.MessageConst.*;

/**
 * 메시지 출력을 관리하는 유틸 클래스
 */
public class MessageUtil {

    public void printInitMsg() {
        System.out.println(START_GAME_MSG);
    }

    public void printInputMsg() {
        System.out.print(INPUT_MSG);
    }

    public void printResultMsg(int ball, int strike) {
        StringBuilder result = new StringBuilder("");

        if (ball == 0 && strike == 0) {
            System.out.println(NOTHING);
            return;
        }
        if (ball != 0) {
            result.append(ball).append(BALL).append(" ");
        }
        if (strike != 0) {
            result.append(strike).append(STRIKE);
        }

        System.out.println(result.toString().trim());
    }

    public void printSuccessMsg() {
        System.out.println(SUCCESS_MSG);
        System.out.println(GAME_CONTROL_MSG);
    }
}

- 여기서 신경쓴 부분은 볼, 스트라이크 개수를 출력해주는 부분이다.

개수에 따라서 제어해야 하기 때문에 각각에 대해 기능을 나눌까도 싶었지만...

StringBuilder를 통해 조건에 해당하는 경우에 대해서 값을 추가해주고, 혹시 몰라 마지막에 trim을 넣어서 양끝에 붙은 공백을 제거해주었다.

if문이 너무 많은 게 좀 그런가 싶지만...! 오히려 '결과 출력' 이라는 하나의 기능 관점에서 봤을 때 더 적합한 것 같아서 마음에 든다.

---

| InputValidation

- 검증 관련 기능을 담은 클래스이다. 

package baseball.validation;

        import java.util.Arrays;
        import java.util.List;
        import java.util.stream.Collectors;

        import static baseball.constant.MessageConst.*;
        import static baseball.constant.NumberConst.*;

/**
 * 입력값에 대한 검증을 진행하는 클래스
 */
public class InputValidation {

    /**
     * 사용자의 숫자 입력값에 대한 모든 검증을 진행한다.
     */
    public List<Integer> validateInputNum(String input) {
        validateInputLength(input);
        List<Integer> inputNums = changeStrToList(input);
        validateInputRange(inputNums);
        validateInputDuplicated(inputNums);

        return inputNums;
    }

    private List<Integer> changeStrToList(String input) {
        return Arrays.stream(input.split(""))
                .map(Integer::parseInt)
                .collect(Collectors.toList());
    }

    /**
     * 입력값의 길이가 3인지 검증한다.
     *
     * @param input 사용자의 입력값
     */
    public void validateInputLength(String input) {
        if (input.length() != INPUT_LENGTH) {
            throw new IllegalArgumentException(INPUT_LENGTH_EXCEPTION_MSG);
        }
    }

    /**
     * 입력값이 1~9 사이의 숫자인지 검증한다.
     *
     * @param inputNums 사용자의 입력값의 각 자리를 쪼갠 리스트
     */
    public void validateInputRange(List<Integer> inputNums) {
        boolean checkRange = inputNums.stream()
                .allMatch(num -> FIRST_RANGE <= num && num <= LAST_RANGE);

        if (!checkRange) {
            throw new IllegalArgumentException(INPUT_RANGE_EXCEPTION_MSG);
        }
    }

    /**
     * 입력값에 중복된 값이 존재하는지 검증한다.
     *
     * @param inputNums 사용자의 입력값의 각 자리를 쪼갠 리스트
     */
    public void validateInputDuplicated(List<Integer> inputNums) {
        if (inputNums.stream().distinct().count() != INPUT_LENGTH) {
            throw new IllegalArgumentException(INPUT_DUPLICATE_EXCEPTION_MSG);
        }
    }

    /**
     * 게임 진행을 제어하는 입력값에 대해 검증한다.
     *
     * @param input 사용자의 입력값
     */
    public void validateGameControlInput(int input) {
        if (input < RESTART_NUM || input > EXIT_NUM) {
            throw new IllegalArgumentException(GAME_CONTROL_EXCEPTION_MSG);
        }
    }
}

- 이 부분도 로직에서 꽤 수정을 거친 부분들이 있다.

우선 입력값이 1~9 사이인지 검증하는 부분.

-> 사실 초기에는 '숫자 input' 중에서 0이 아닌 경우만 체크할 예정이었다.  그리고 따로 문자/숫자를 체크하는 메서드를 만들려고 했다.

물론 이 부분은 정규식을 쓰면 간단하게 해결되지만, 중요한 건 정규식은 결국 하나의 '문자'에 대해서 체크를 하는 것이기 때문에, 메서드 내부 호출이든, 외부 호출이든 반복문을 돌아줘야 하는 부분이 생기는 것이었다.

 

for-each 구문을 사용해서 처리할 수 있는 부분이지만, 조금 더 코드를 간결하게 하고 싶어서 stream을 바로 써먹었다.

stream().allMatch()를 활용해서 각각의 값들에 대한 조건이 일치하는지 검증이 쉽게 가능했던 것!

덕분에 1~9 사이라는 것도 <=를 활용해 비교할 수 있으니 조금 더 직관적으로 가져갈 수 있었고, 무엇보다 코드가 심플해서 마음에 든다.

 

- 다음으로는 중복된 값 검증 부분이다.

사실 이 부분도 원래는 컴퓨터가 생성하는 것처럼 contains를 통해 리스트에 집어넣고, 리스트의 사이즈가 3인지 체크하려고 했다.

하지만, 그렇게 짜는 코드는 사실 로직 이해도 복잡하고, 무엇보다 코드가 길어지면서 너무 마음에 안 들기 때문에 또 다시 Stream을 찾았다.

그리고 발견한 stream().distinct().count()! 각 요소들 중에 중복되지 않은 값들을 카운트하기 때문에 처음의 로직을 그대로 따라가면서 코드가 간결해지는 게 너무 마음에 들었다.

앞으로도 stream... 애용해줄게 😎

애용이

---

| BaseballGame

- 핵심 로직이 담긴 게임 클래스!

package baseball;

        import baseball.util.ComputerUtil;
        import baseball.util.MessageUtil;
        import baseball.util.UserUtil;
        import baseball.validation.InputValidation;

        import java.util.List;

        import static baseball.constant.NumberConst.*;

/**
 * 게임을 제어하는 메인 클래스
 */
public class BaseballGame {
    private final UserUtil userUtil = new UserUtil();

    private final MessageUtil messageUtil = new MessageUtil();

    private final ComputerUtil computerUtil = new ComputerUtil();

    private final InputValidation validator = new InputValidation();

    private List<Integer> computerNums;

    public BaseballGame() {
        messageUtil.printInitMsg();
    }

    public void startGame() {
        int gameControlNum = RESTART_NUM;
        computerNums = computerUtil.generateNumber();

        while (gameControlNum == RESTART_NUM) {
            messageUtil.printInputMsg();
            String userInput = userUtil.getInputNumber();
            List<Integer> userNums = validator.validateInputNum(userInput);

            ResultCount result = compareNumber(computerNums, userNums);
            int ball = result.ballCount;
            int strike = result.strikeCount;
            messageUtil.printResultMsg(ball, strike);

            gameControlNum = checkStrikeCount(strike);
        }
    }

    private ResultCount compareNumber(List<Integer> computerNums, List<Integer> userNums) {
        int ball = 0, strike = 0;

        for (int i = 0; i < INPUT_LENGTH; i++) {
            int computerNum = computerNums.get(i);
            int userNum = userNums.get(i);

            if (computerNum == userNum) {
                strike++;
                continue;
            }

            if (computerNums.contains(userNum)) {
                ball++;
            }
        }

        return new ResultCount(ball, strike);
    }

    private static class ResultCount {
        int ballCount;
        int strikeCount;

        public ResultCount(int ballCount, int strikeCount) {
            this.ballCount = ballCount;
            this.strikeCount = strikeCount;
        }
    }

    private int checkStrikeCount(int strike) {
        int gameControlInput = RESTART_NUM;

        if (strike == MAX_STRIKE) {
            messageUtil.printSuccessMsg();
            gameControlInput = Integer.parseInt(userUtil.getInputNumber());
            validator.validateGameControlInput(gameControlInput);

            checkRestartNumAndMakeComputerNum(gameControlInput);
        }

        return gameControlInput;
    }

    private void checkRestartNumAndMakeComputerNum(int gameControlInput) {
        if (gameControlInput == RESTART_NUM) {
            computerNums = computerUtil.generateNumber();
        }
    }
}

- 메인 클래스이다. 지금 와서 아쉬운 건 메서드를 더 나눴어야 했는데 덜 나눈 거. 혹은 클래스라거나?

그래도 생성자를 통해서 초기 메시지를 출력해주는 부분은 설계와 잘 맞아떨어지는 것 같아서 좋았다.

 

- 이후 로직은 '사용자의 인풋 검증 > 비교 > 카운트 > 스트라이크 개수 체크 > 반복' 이것뿐이어서 간단하다.

신경썼던 부분이라고 하면... 카운트 시 개수 리턴했을 때 리스트로 할 것인지, 아니면 내부 클래스를 사용할 것인지.

처음에는 그냥 List.of로 반환하려고 하였으나, 그러면 각각의 값에 대한 전달이 너무 부족할 것 같아 클래스로 사용하였다.

다만... private static inner class를 테스트 코드에서 어떻게 접근해야 될지 답을 못 구해서 이 부분에 대한 테코를 못 짠 건 아쉽다 ㅠ_ㅠ

그렇다고 접근 지정자를 열어버리기에는 싫고... 아마 리플렉션으로 어케 하면 될 텐데 이건 좀 더 고민해봐야 할 것 같다.

 

- 다음으로는 스트라이크 횟수 체크 부분이다. 재시작을 눌렀을 때 컴퓨터가 '1회 한정으로 새로운 수'를 생성해야 했기 때문에,

이 부분을 초기 while문 내에 집어넣기에는 루프가 돌 때마다 수를 생성하게 되고, 그렇다기에는 스트라이크 = 3일 때 + 재시작을 눌렀을 때 수를 생성해야 하니까 다른 곳에서 넣어주기도 애매해서 저기에 넣었다.

다만 그것보다 더 좋은 방향이 있지 않았을까... 라는 아쉬움이 남는 건 어쩔 수 없다. 이건 설계의 잘못이었겠지 ㅠ

그래도 if문 내에 if문 넣는 건 너무 보기 싫어서 바로 메서드로 추출했다. 하염없이 긴 메서드명이지만 가장 잘 나타냈는걸....

 

---

| 너무나도 어려웠던 테스트 코드

- 삽질을 어마무시하게 했던 테스트 코드... 😅 하지만 그만큼 이번 주차 과제에서 배운 점이 가장 많다.

- 처음 테코를 받고 느낀 건, '컴퓨터는 랜덤하게 값을 생성할 텐데, 어떻게 고정된 결과가 나오지?' 이거였다.

내부의 인자는 또 무엇이고, run은 무엇이며, contains 내부의 값은 뭐고, value는... values는....?

진짜 뭔 소리야...? 라는 생각뿐이었다. 당연하다. 테스트 코드 제대로 짜본 적이 없으니까.

그래서 바로 코드를 까보기 시작했다.

- 우선 run을 살펴보면 내부에서 command를 호출하는데, 사용자가 입력하는 것처럼 콘솔에 값을 넣어주는 것이었다. (System.setIn)

- 그럼, 첫 번째는 사용자가 순차적으로 입력한 값이라는 거라는 건 알았고, 그 다음은...?

- 여기서 output 메서드의 내부에서 쓰인 captor는 outputStream이다. 즉, 결과를 받아온 것!

 

- 그럼 여기까지 봤을 때 의미하는 게 결국, 사용자가 246 > 135 > 1 > 597 > 589 > 2를 순차적으로 누른 것이고, 출력의 결과 값으로 낫싱, 3스트라이크, 1볼 1스트라이크, 3스트라이크, 게임 종료가 포함되어 있음을 알 수 있다.

 

그렇다면, 그 다음 인자인 1, 3, 5, 5, 8, 9는...?

- 우선 까고 들어가보기. 내부에서 또 다른 함수를 호출하는 걸 볼 수 있다.

이때, 우리가 컴퓨터가 값을 생성할 때 사용한 pickNumberInRange도 사용한 것을 볼 수 있다!

그래서 다시 들어가보면, 다음과 같은 구조인데...

우선 1차적으로 타임아웃을 걸었다는 점을 알 수 있고 (실제로 실행 결과가 10초 이상이면 테스트가 종료된다.)

MockStatic을 통해 mocking을 진행한 것을 알 수 있다! 바로, Randoms.class에 대해서!

 

mock.when.thenReturn 구조는 when으로 주어졌을 때 리턴을 하는 건데,  이때 value를 시작으로 여러 개의 리턴값을 주고 싶다면 values의 값을 하나씩 꺼내서 사용하게 된다.

 

이게 무슨 말이냐면!

나의 초기 의문은 '컴퓨터는 랜덤하게 값을 생성할 텐데 어떻게 항상 같은 값이 도출되는가?' 이었다.

근데, 컴퓨터가 랜덤하게 값을 생성할 때 무엇을 사용하지?

- 바로, Randoms의 pickNumberInRange를 사용한다!

우리는 앞서 mocking 시에 Randoms.class를 타켓으로 잡았기 때문에 해당 클래스의 static method인 pickNumberInRange는 타겟 대상이다.

그렇기 때문에, 저 메서드가 실행이 될 때 리턴 값으로 value ~ values 내부의 값을 주는 것이다.

 

그렇다면 다시 테스트 코드를 보자.

- 여기서 사용자는 6번의 명령어를 입력한다. 그리고, 중간에 1, 2가 끼는 것을 보아서 1(재시작), 2(종료)를 호출한 것을 볼 수 있고,

이는 곧 2번의 게임이 진행됐음을 알 수 있는 결과이다.

2번의 게임이 진행됐다면 컴퓨터는 값을 몇 번 생성했을까? 바로 2번 생성했을 것이다.

그러면 저 내부의 pickNumberInRange 메서드는 몇 번 호출됐을까? 중복된 값이 들어오지 않았기에 3번씩 총 6번이 호출되었을 것이고, 리턴 값으로 1, 3, 5 || 5, 8, 9를 받아 결과적으로 컴퓨터가 생성한 글자가 늘 135, 589가 되었던 것이다!

 

이걸 알고 너무 놀랬다. 아, 이래서 사용하라는 라이브러리를 쓰라고 하신 거구나... ㅎㅎ

무엇보다 나는 저 부분을 간과하고 넘어가서 로직 상에 오류로 인해 무한루프에 걸렸었다.

(사유: 컴퓨터가 새로운 숫자 생성을 재시작 시에만 했어야 했는데 종료 때도 해줘서 - if문의 누락... 

종료가 됐는데도 계속 마지막 리턴값인 9를 가져오면서 contains 조건에 의해 리스트에 값이 채워지지 않아 size가 증가하지 않으면서 무한루프 발생!)

 

이래서... 코드를 까보는 습관이 매우 중요하다는 걸 알았다.

그리고 테스트 코드에 너무 흥미가 갔던 순간이었다... ㅠ_ㅠ

 

    @Test
@DisplayName("문자열에서 정수 리스트로 변환 테스트")
    void 문자열_리스트_변환_테스트() throws Exception {
            // given
            InputValidation inputValidation = new InputValidation();
            Method method = inputValidation.getClass().getDeclaredMethod("changeStrToList", String.class);
        method.setAccessible(true);

        // when
        String input = "123";
        List<Integer> inputNums = (List<Integer>) method.invoke(inputValidation, input);

        // then
        List<Integer> correct = new ArrayList<>();
        correct.add(1);
        correct.add(2);
        correct.add(3);

        assertThat(inputNums).isEqualTo(correct);
        }

- 아무튼, 마음 다잡고 테스트 코드를 짰다. 전에 테코톡에서 리플렉션 강좌 봤던 게 생각나서 private로 선언된 메서드 가져오는 건 헤매지 않았다...!

.getClass().getDeclaredMethod(method_name, parameter_type) 기억해두자.

 

 @Test
@DisplayName("사용자의 입력값 길이 테스트")
    void 사용자_입력_길이_테스트() {
            // given
            InputValidation inputValidation = new InputValidation();

            // when
            String userCorrectInput = "123";
            String userLessInput = "12";
            String userMoreInput = "1234";

            // then
            assertThatCode(() ->
            inputValidation.validateInputLength(userCorrectInput))
            .doesNotThrowAnyException();

            assertThatThrownBy(() ->
            inputValidation.validateInputLength(userLessInput))
            .isInstanceOf(IllegalArgumentException.class)
        .hasMessageContaining(MessageConst.INPUT_LENGTH_EXCEPTION_MSG);

        assertThatThrownBy(() ->
        inputValidation.validateInputLength(userMoreInput))
        .isInstanceOf(IllegalArgumentException.class)
        .hasMessageContaining(MessageConst.INPUT_LENGTH_EXCEPTION_MSG);
        }

- 여기서는 그냥 예외 테스트만 진행했다. 사실 테스트 코드 까느라 시간을 많이 잡아먹어서 예외밖에 못 한 게 맞다....

그래도 .hasMessageContaining을 통해 메시지까지 함께 검증해볼 수 있었다.

 

나머지는 비슷하니까 넘기고, 다른 테코를 마지막으로 소개해보자면!

   @Test
@DisplayName("재시작/종료 시 사용자의 입력값 검증 테스트")
    void 재시작_종료_시_사용자_입력값_테스트() throws Exception {
            // given
            BaseballGame baseballGame = new BaseballGame();
            Method method = baseballGame.getClass().getDeclaredMethod("checkStrikeCount", int.class);
        method.setAccessible(true);

        // when, then
        try {
        command("3");
        method.invoke(baseballGame, NumberConst.MAX_STRIKE);
        } catch (InvocationTargetException e) {
        assertThat(e.getTargetException())
        .isInstanceOf(IllegalArgumentException.class)
        .hasMessageContaining(MessageConst.GAME_CONTROL_EXCEPTION_MSG);
        }
        }

- 여기서는 command까지 사용했다. 사실 내 로직 자체가 스트라이크 카운트가 3일 때 재시작, 종료 검증을 위해서라면 사용자로부터 값을 입력받아야 했기 때문에... 우테코 내부에 구현되어 있던 command를 슬쩍 가져왔다. (사실 이 테스트 코드는 맞게 짠지 잘 모르겠다...)

실행해서 사용자가 3을 입력하면 예외 발생시키고 메시지 잘 터트리는지 확인하는 건데 사실 저거 몇 줄 짜는 것도 혼자 헷갈려 했다.

아직 테스트 코드는 너무 초보야... 😅

---

| 소감

- 마찬가지로 캡쳐로 대신할 예정.

 

 

 

아무튼 이번 주차는 너무 배운 것도 많고, 삽질한 것도 많아서 시간이 후딱 갔다.

매순간 잘하는 분들도 많고, 그 모습에 지친 적도 너무너무 많은 나여서 우테코 도전도 사실 두려움이 더 많았지만...

어찌저찌 해내려고 노력하고 있는 모습에만 조금 더 집중하고자 한다.

처음 하는 건데 못 하는 게 당연한 거니까!!!!!!! 기죽지 말자 아자아자

 

그래도! 3주차에는 조금 더 나아진 내 모습을 기대하면서... ㅠㅠ 남은 2주도 파이팅!