우테코 프리코스 1주차 피드백 정리(개발 요구사항 작성, 객체 지향 프로그래밍, junit)

1주차 피드백 정리

이 글은 우테코 1차 과제 피드백을 통해 배운 점을 기록하는 글입니다. 강의를 보고 새로 작성한 코드는 아래 링크에서 보실 수 있습니다.

https://github.com/kite707/java-baseball-6/tree/kite707_feedback

GitHub - kite707/java-baseball-6

먼저 이번 1주차의 공통 피드백은 다음과 같았습니다.

1. 요구 사항을 정확히 준수한다.
2. 커밋 메시지를 의미있게 작성한다.
3. git을 통해 관리할 자원에 대해서도 고려한다.
4. Pull Request를 보내기 전 브랜치를 확인한다.
5. PR을 한 번 작성했다면 닫지 말고 추가 커밋을 한다.
6. 이름을 통해 의도를 드러낸다.
7. 축약하지 않는다.
8. 공백도 코딩 컨벤션이다.
9. 공백 라인을 의미 있게 사용한다.
10. space 와 tab을 혼용하지 않는다.
11. 의미 없는 주석을 달지 않는다.
12. IDE의 코드 자동 정렬 기능을 활용한다.
    mac : ⌥⌘L
    window : Ctrl+Alt+L
13. Java에서 제공하는 API를 적극 활용한다.
    ex)List<String> members = Arrays.asList("pobi", "jason");
         String result = String.join(",", members); // "pobi,jason"
14. 배열 대신 Java Collection을 사용한다. Map, Set, List 등

이 중에서 제가 참고할만한 부분은 굵게 표시하였습니다.

 

우테코에서는 1주차 과제인 “숫자 야구 게임”에 대해 영상 피드백도 제공하였습니다. Java에 대한 기초적인 내용들과 “숫자 야구 게임” 과제를 수행하는 모습을 라이브 코딩으로 보여주는 영상이었습니다.

 

라이브 코딩을 하기 앞서 제이슨은 객체 지향 프로그래밍을 하는 방법에 대해 아래와 같이 말했습니다.

1. 기능을 가지고 있는 클래스를 인스턴스화 한다.
2. 필요한 기능을 인스턴스가 수행하게 한다.(의인화)
3. 각 결과를 종합한다.

 

이후 개발 문서를 작성하였습니다. 우테코에서는 개발 요구사항을 문서로 정리한 뒤 개발을 시작할 것을 권장합니다. 제가 이전에 작성했던 개발 요구사항 문서는 아래와 같았습니다.

## 기능 구현

- [x] 3자리 임의의 정답 생성
- [x] 사용자의 입력을 받아 볼, 스트라이크 등의 결과 출력
- [x] 게임 재시작여부 결정 기능

## 예외 처리

입력값이 조건에 부합하지 않을 시 IllegalArgumentException 발생

- [x] 사용자가 숫자가 아닌 값을 입력했을 때
- [x] 사용자가 3자리가 아닌 값을 입력했을 때
- [x] 게임 재시작 여부를 결정할 때 1이나 2가 아닌 다른 값을 입력했을 때

강의에 등장한 개발 요구사항 문서는 아래와 같았습니다.

# 숫자 야구 게임

## 기능 목록

- [x] 1-9까지의 서로 다른 임의의 수 3개를 생성한다. NumberGenerator/createRandomNumbers()
- [x] 컴퓨터의 수와 플레이어의 수를 비교한다. - Referee(심판)/compare()
    - [x] 몇 개의 숫자가 같은지 알 수 있다. - Judgement/correctCount()
    - [x] 특정 자리에 특정 숫자가 있는지 알 수 있다. - Judgement/hasPlace()
- [x] 같은 수가 다른 자리에 있으면 볼이다.
- [x] 같은 수가 같은 자리에 있으면 스트라이크이다.
- [x] 같은 수가 전혀 없으면 낫싱이다.

## 기능 요구 사항

기본적으로 1부터 9까지 서로 다른 수로 이루어진 3자리의 수를 맞추는 게임이다.

같은 수가 같은 자리에 있으면 스트라이크, 다른 자리에 있으면 볼, 같은 수가 전혀 없으면 낫싱이란 힌트를 얻고, 그 힌트를 이용해서 먼저 상대방(컴퓨터)의 수를 맞추면 승리한다.

e.g. 상대방(컴퓨터)의 수가 425일 때
123을 제시한 경우 : 1스트라이크
456을 제시한 경우 : 1볼 1스트라이크
789를 제시한 경우 : 낫싱

기능 목록을 작성하며 어떤 파일에 어떤 함수들을 배치할지 계획하여 함께 작성한 것을 볼 수 있습니다. 저는 각 기능을 메서드화하기는 했지만 모든 기능들이 Application.java파일에 존재했습니다. 개발 문서를 작성하는 부분을 통해 각 기능을 가지고 있는 클래스를 인스턴스화 하여 필요한 기능을 인스턴스가 수행하게 한다. 라는 것이 어떤 말인지 느낄 수 있었습니다.

 

이후 위에서 본대로 NumberGenerator, Referee, Judgement 파일을 만들어 각각 createRandomNumbers(), compare()등의 메서드를 구현합니다.

 

즉 현재까지의 프로젝트 구조는 아래와 같습니다.

이후 각 결과를 종합하여 Application.java파일을 구성합니다. 참고를 위해 Jason이 작성한 코드와 제가 작성한 코드를 첨부하도록 하겠습니다.

//Jason의 코드
package baseball;

import baseball.domain.NumberGenerator;
import baseball.domain.Referee;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Application {
    public static void main(String[] args) {
        NumberGenerator generator = new NumberGenerator();
        List<Integer> computer = generator.createRandomNumbers();

        Referee referee = new Referee();

        String result = "";
        while (!result.equals("0 볼 3 스트라이크")) {
            result = referee.compare(computer, askNumbers());
            System.out.println(result);
        }
        System.out.println("3개의 숫자를 모두 맞히셨습니다! 게임 종료");

    }

    public static List<Integer> askNumbers() {
        System.out.println("숫자를 입력해 주세요 : ");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.next();

        List<Integer> numbers = new ArrayList<>();
        for (String number : input.split("")) {
            numbers.add(Integer.valueOf(number));
        }
        return numbers;
    }
}

//제출 코드
package baseball;

import camp.nextstep.edu.missionutils.Console;
import camp.nextstep.edu.missionutils.Randoms;
import java.util.ArrayList;
import java.util.List;

public class Application {
    public static final int BALL = 1;
    public static final int STRIKE = 2;
    public static final int NOTHING = 3;
    public static final int RESTART = 1;
    public static final int LENGTH = 3;

    public static List<Integer> getAnswer() {
        List<Integer> answer = new ArrayList<>();
        while (answer.size() < LENGTH) {
            int randomNumber = Randoms.pickNumberInRange(1, 9);
            if (!answer.contains(randomNumber)) {
                answer.add(randomNumber);
            }
        }
        return answer;
    }

    public static Integer ballOrStrike(int idx, char userInput, List<Integer> answer) {
        int result = NOTHING;
        int curInput = userInput - '0';
        if (answer.contains(curInput)) {
            result = BALL;
        }
        if (answer.get(idx) == curInput) {
            result = STRIKE;
        }
        return result;
    }

    public static boolean evaluator(String userInput, List<Integer> answer) {
        int strike = 0;
        int ball = 0;

        for (int i = 0; i < userInput.length(); i++) {
            char curInput = userInput.charAt(i);
            int result = ballOrStrike(i, curInput, answer);
            if (result == BALL) {
                ball++;
            }
            if (result == STRIKE) {
                strike++;
            }
        }
        return replyToUser(strike, ball);
    }

    public static boolean replyToUser(int strike, int ball) {
        if (strike == 3) {
            System.out.println("3스트라이크\n3개의 숫자를 모두 맞히셨습니다! 게임 종료");
            return false;
        }
        if (ball > 0) {
            System.out.print(ball + "볼 ");
        }
        if (strike > 0) {
            System.out.print(strike + "스트라이크 ");
        }
        if (strike == 0 && ball == 0) {
            System.out.print("낫싱");
        }
        System.out.println();
        return true;
    }

    public static boolean isGameRestart(String userRestart) {
        if (userRestart.charAt(0) - '0' == RESTART) {
            return true;
        }
        return false;
    }

    public static void validateUserInput(String userInput) {
        if (userInput.length() != LENGTH) {
            throw new IllegalArgumentException();
        }
        for (int i = 0; i < userInput.length(); i++) {
            int curInput = userInput.charAt(i) - '0';
            if (curInput < 0 || curInput > 9) {
                throw new IllegalArgumentException();
            }
        }
    }

    public static void validateUserRestart(String userRestart) {
        if (userRestart.length() != 1) {
            throw new IllegalArgumentException();
        }
        int curInput = userRestart.charAt(0) - '0';
        if (curInput != 1 && curInput != 2) {
            throw new IllegalArgumentException();
        }
    }

    public static void main(String[] args) {
        System.out.println("숫자 야구 게임을 시작합니다.");
        boolean isGameRestart = true;
        while (isGameRestart) {
            List<Integer> answer = getAnswer();
            boolean isIncorrect = true;
            while (isIncorrect) {
                System.out.print("숫자를 입력해주세요 : ");
                String userInput = Console.readLine();
                validateUserInput(userInput);
                isIncorrect = evaluator(userInput, answer);
            }
            System.out.println("게임을 새로 시작하려면 1, 종료하려면 2를 입력하세요.");
            String userRestart = Console.readLine();
            validateUserRestart(userRestart);
            isGameRestart = isGameRestart(userRestart);
        }

    }
}

제 코드의 경우 main함수에서 모든 기능을 수행하고 있기 때문에 코드가 상당히 길고, 객체 지향의 원칙을 따르지 못한 것을 보실 수 있습니다.

 

이후에는 테스트 코드를 짜는 것을 보여주셨는데 테스트 코드의 경우 Referee class에 대하여 작성하였습니다. 테스트 코드를 보기 앞서 Referee코드를 보도록 하겠습니다.

 

컴퓨터가 생성한 세 자리 수와 플레이어가 입력한 세 자리 수를 비교하여 볼, 스트라이크를 각각 출력하는 기능을 하는 코드입니다.

package baseball.domain;

import java.util.List;

public class Referee {
    public String compare(List<Integer> computer, List<Integer> player) {
        final Judgement judgement = new Judgement();
        int correctCount = judgement.correctCount(computer, player);

        int strike = 0;
        for (int placeIndex = 0; placeIndex < player.size(); placeIndex++) {
            if (judgement.hasPlace(computer, placeIndex, player.get(placeIndex))) {
                strike++;
            }
        }
        int ball = correctCount - strike;
        if (correctCount == 0) {
            return "낫싱";
        }
        return ball + " 볼 " + strike + " 스트라이크";
    }
}

인텔리제이를 사용한다면 맥북의 경우 해당 파일에서 ⌘+shift+T, 윈도우는 ctrl+shft+T를 누르면 아래와 같은 파일이 자동 생성됩니다.

package baseball.domain;

import static org.junit.jupiter.api.Assertions.*;

class RefereeTest {

}

이후 스트라이크, 볼이 잘 리턴되는지 아래와 같이 compare()함수의 기능을 검증하는 테스트 코드를 작성하였습니다. 가독성을 위해 import문은 제거하였습니다.

 

여기서 주목할만한 점은 각 테스트에서 중복되는 부분을 미리 private 변수로 선언해주었다는 점, referee클래스의 생성자를 각 테스트가 수행되기 전에 실행하기 위해 @BeforeEach를 사용했다는 점입니다.

class RefereeTest {
        **//중복되는 부분 미리 변수로 선언
    private Referee referee;
    private static final List<Integer> ANSWER = Arrays.asList(1, 2, 3);

    @BeforeEach //각 테스트가 수행되기 전 실행
    void setUp() {
        referee = new Referee();
    }**

    @Test
    void 스트라이크3() {
        String result = referee.compare(ANSWER, Arrays.asList(1, 2, 3));
        assertThat(result).isEqualTo("0 볼 3 스트라이크");
    }

    @Test
    void 낫싱() {
        String result = referee.compare(ANSWER, Arrays.asList(7, 8, 9));
        assertThat(result).isEqualTo("낫싱");
    }

    @Test
    void 볼3() {
        String result = referee.compare(ANSWER, Arrays.asList(2, 3, 1));
        assertThat(result).isEqualTo("3 볼 0 스트라이크");
    }

    @Test
    void 볼2_스트라이크1() {
        String result = referee.compare(ANSWER, Arrays.asList(1, 3, 2));
        assertThat(result).isEqualTo("2 볼 1 스트라이크");
    }

}

그런데 이 경우에도 코드에 중복되는 부분이 상당히 많습니다. 이를 개선하기 위해 @ParameterizedTest와 @CsvSource를 사용하였습니다. 코드가 훨씬 간결해 진 것을 확인할 수 있습니다.

class RefereeTest {
    private Referee referee;
    private static final List<Integer> ANSWER = Arrays.asList(1, 2, 3);

    @BeforeEach
    void setUp() {
        referee = new Referee();
    }

    @ParameterizedTest
    @CsvSource({"1,2,3,0 볼 3 스트라이크", "7,8,9,낫싱", "2,3,1,3 볼 0 스트라이크", "1,3,2,2 볼 1 스트라이크"})
    public void compare(int number1, int number2, int number3, String expected) {
        String actual = referee.compare(ANSWER, Arrays.asList(number1, number2, number3));
        assertThat(actual).isEqualTo(expected);
    }

위 코드를 보고 간단하게 설명하자면 @CsvSource의 인자로 주어지는 큰 따옴표의 시작점부터 끝 점이 하나의 테스트라고 생각하시면 됩니다. 즉 아래 코드에서는 "1,2,3,0 볼 3 스트라이크"가 하나의 테스트가 되겠죠?

 

이 테스트는 ,(콤마) 단위로 compare()함수의 인자로 들어가게 되는데 여기서는 각 인자의 값이 아래와 같이 됩니다.

📚 compare()함수의 인자
number1 = 1
number2 = 2
number3= 3
expected = 0 볼 3 스트라이크

여기까지만 봐도 @ParameterizedTest와 @CsvSource의 사용법을 직관적으로 익힐 수 있습니다.

@ParameterizedTest는 다양한 어노테이션과 함께 사용됩니다. 즉 파라미터로 어떤 값이 주어질지를 알려주는 어노테이션과 함께 사용해야 하는데요. @CsvSource외의 다른 어노테이션을 살펴보도록 하겠습니다.

1. ValueSource

ValueSource는 다양한 타입의 파라미터를 배열로 받아 사용할 수 있게 해주는 어노테이션입니다. 각 타입명의 소문자에 s를 붙여 파라미터의 타입을 알려줍니다. 다만 파라미터 인자는 1개만 넣을 수 있습니다. 즉 아래와 같이 사용합니다.

@ParameterizedTest
    @ValueSource(ints = {1, 2, 3, -1})
    public void compare(int number1) {
        assertThat(number1 > 0).isEqualTo(true);
    }

number1에 1, 2, 3, -1이 들어갔을때의 테스트 결과를 각각 확인할 수 있습니다.

2. CsvSource

CSV(Comma Seperated Values)는 콤마를 기준으로 CSV를 구분하여 읽습니다. 여기서의 구분자 콤마는 기본값이며 커스터마이징이 가능합니다. 앞서 본 것과 같이 각 String값을 콤마로 구분해 각 인자에 집어넣습니다. 즉 여러개의 인자를 받는 함수도 테스트가 가능합니다.

@ParameterizedTest
    @CsvSource({"1,2,3,0 볼 3 스트라이크", "7,8,9,낫싱", "2,3,1,3 볼 0 스트라이크", "1,3,2,2 볼 1 스트라이크"})
    public void compare(int number1, int number2, int number3, String expected) {
        String actual = referee.compare(ANSWER, Arrays.asList(number1, number2, number3));
        assertThat(actual).isEqualTo(expected);
    }

3. MethodSource

복잡한 인수들을 파라미터로 넘기는 방법입니다. Stream을 반환하는 static 메서드를 작성해주면 되는데 사용 예시를 살펴보겠습니다.

먼저 아래와 같이 Integer리스트를 받아 리스트 속 값들을 합쳐주는 함수가 있다고 가정하겠습니다.

public class MathUtils {
    public static int sum(List<Integer> numbers) {
        return numbers.stream().mapToInt(Integer::intValue).sum();
    }
}

그리고 테스트 코드는 아래와 같이 작성합니다.

class MathUtilsTest {

        //stream을 반환하는 static 메서드
    static Stream<List<Integer>> provideNumberLists() {
        return Stream.of(
                Arrays.asList(1, 2, 3, 4, 5),
                Arrays.asList(10, 20, 30, 40, 50),
                Arrays.asList(2, 4, 6, 8, 10)
        );
    }

    @ParameterizedTest
    @MethodSource("provideNumberLists")
    void testSum(List<Integer> numbers) {
        int expectedSum = numbers.stream().mapToInt(Integer::intValue).sum();
        assertEquals(expectedSum, MathUtils.sum(numbers));
    }
}

Stream을 반환하는 static 메서드를 인자로 넘겨주어 해당 메서드를 실행한 결과를 하나씩 인자에 넣습니다. 예를 들어 numbers에는 Arrays.asList(1, 2, 3, 4, 5), Arrays.asList(10, 20, 30, 40, 50), Arrays.asList(2, 4, 6, 8, 10)의 값이 하나씩 들어가 총 3번의 테스트가 수행되겠죠?

실제로도 세 번의 테스트가 수행되는 것을 볼 수 있습니다.

추가적으로 인자를 여러개 넘기고 싶다면 아래와 같이 Arguments.arguments를 사용하면 됩니다.

static Stream<Arguments> provideNumberLists() {
        return Stream.of(
                Arguments.arguments(Arrays.asList(1, 2, 3, 4, 5), 15),
                Arguments.arguments(Arrays.asList(10, 20, 30, 40, 50), 150),
                Arguments.arguments(Arrays.asList(2, 4, 6, 8, 10), 30)
        );
    }

    @ParameterizedTest
    @MethodSource("provideNumberLists")
    void testSum(List<Integer> numbers, int answer) {
        assertEquals(answer, MathUtils.sum(numbers));
    }

Arguments.arguments로 묶인 부분을 하나의 테스트로 보면 됩니다. 그리고 그 속 인자들이 각각 테스트 함수의 인자로 들어가게 되는데요. Arguments.arguments(Arrays.asList(1, 2, 3, 4, 5), 15)부분에서는 아래와 같이 인자에 값이 할당되게 됩니다.

📚 testSum함수의 인자(Arguments.arguments(Arrays.asList(1, 2, 3, 4, 5), 15))
numbers = Arrays.asList(1, 2, 3, 4, 5)
answer = 15

마지막으로 @ParameterisedTest에 주면 좋은 유용한 인자를 소개하고 마치도록 하겠습니다. 바로 name이라는 인자인데요. 현재 위 테스트 코드를 수행하면 아래와 같이 결과가 출력됩니다.

만약 @ParameterizedTest에 name인자를 주게 되면 이 부분을 바꿀 수 있습니다.

 

아래와 같이 코드를 작성하고 실행해보면

class MathUtilsTest {

    static Stream<Arguments> provideNumberLists() {
        return Stream.of(
                Arguments.arguments(Arrays.asList(1, 2, 3, 4, 5), 15),
                Arguments.arguments(Arrays.asList(10, 20, 30, 40, 50), 150),
                Arguments.arguments(Arrays.asList(2, 4, 6, 8, 10), 30)
        );
    }

    **@ParameterizedTest(name = "주어진 값 : {0}, 결과 : {1}") //name 인자 사용**
    @MethodSource("provideNumberLists")
    void testSum(List<Integer> numbers, int answer) {
        assertEquals(answer, MathUtils.sum(numbers));
    }
}

아래와 같이 테스트의 제목이 바뀐 것을 확인할 수 있습니다.

📚Reference

https://theamabile.tistory.com/21

[인텔리제이 / Intelli J] 인텔리제이에서 테스트 클래스 생성 단축키

https://zzang9ha.tistory.com/344

JUnit - @ParameterizedTest, @ValueSource, @CsvSource, @MethodSource 어노테이션

https://ebabby.tistory.com/28

[JUnit] @ParameterizedTest - @MethodSource 사용하기