[로또] 이준섭 미션 제출합니다.

docs/README.md

@@ -1,14 +1,15 @@
 Application과 동일 선상에 RunLotto 클래스 생성
 
-RunLotto에 필요한 기능들을 패키지로 묶어보자
+LottoManager에 필요한 기능들을 패키지로 묶어보자
 
 - 도메인 모델 패키지 (domain)
     - 사용자로부터 입력받은 구입금액을 저장하는 클래스 PurchaseAmount
     - 난수 생성된 로또 번호가 있는 클래스 Lotto
     - 사용자로부터 로또 번호 6개와 보너스 번호 1개를 입력받아 저장하는 클래스 UserInputNumbers
     - 상금과 당첨 수를 저장하는 열거형 enum WinningCheck
 - 비즈니스 로직을 수행하는 서비스 패키지 (service)
-    - 당첨 결과와 수익률을 계산하는 클래스 Calculator
+    - 당첨 결과를 계산하는 클래스 LottoResultCalculator
+    - 수익률을 계산하는 클래스 LottoProfitRateCalculator
     - 구입금액만큼 로또를 발행하는 클래스 LottoGenerator
 - 각종 메서드가 있는 패키지 (util)
     - 사용자로부터 값들을 입력받는 클래스 InputManager

src/main/java/lotto/Application.java

@@ -3,7 +3,7 @@
 public class Application {
 
   public static void main(String[] args) {
-    RunLotto runLotto = new RunLotto();
-    runLotto.runLotto();
+    LottoManager lottoManager = new LottoManager();
+    lottoManager.runLotto();
   }
 }

src/main/java/lotto/RunLotto.java → src/main/java/lotto/LottoManager.java

@@ -12,7 +12,7 @@
 import lotto.util.OutputManager;
 import lotto.domain.WinningCheck;
 
-public class RunLotto {
+public class LottoManager {
 
   private final InputManager inputManager = new InputManager();
   private final LottoGenerator lottoGenerator = new LottoGenerator();

src/main/java/lotto/domain/Lotto.java

@@ -3,6 +3,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import lotto.util.ErrorMessage;
 
 public class Lotto {
 
@@ -28,18 +29,18 @@ public boolean isBonusMatch(UserInputNumbers receivedLotto) {
 
   private void validateLottoNumbers(List<Integer> lottoNumbers) {
     if (lottoNumbers.size() != SIZE_OF_LOTTO) {
-      throw new IllegalArgumentException("[ERROR] 로또 번호는 총 6개여야 합니다.");
+      throw new IllegalArgumentException(ErrorMessage.NOT_SIX_NUMBERS.getMessage());
     }
 
     for (int number : lottoNumbers) {
       if (number < MIN_LOTTO_NUMBER || number > MAX_LOTTO_NUMBER) {
-        throw new IllegalArgumentException("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+        throw new IllegalArgumentException(ErrorMessage.NOT_IN_RANGE.getMessage());
       }
     }
 
     Set<Integer> uniqueNumbers = new HashSet<>(lottoNumbers);
     if (uniqueNumbers.size() < lottoNumbers.size()) {
-      throw new IllegalArgumentException("[ERROR] 로또 번호는 중복이 없어야 합니다.");
+      throw new IllegalArgumentException(ErrorMessage.MUST_NOT_DUPLICATE.getMessage());
     }
   }
 

src/main/java/lotto/domain/PurchaseAmount.java

@@ -1,32 +1,24 @@
 package lotto.domain;
 
+import lotto.util.ErrorMessage;
+
 public class PurchaseAmount {
 
   public static final int LOTTO_PRICE = 1000;
-  private int amount;
-
-  public PurchaseAmount(String input) {
-    validateIsNumeric(input);
-    int inputAmount = Integer.parseInt(input);
-    validatePurchaseAmount(amount);
-    this.amount = inputAmount;
-  }
+  private final int purchaseAmount;
 
-  private void validateIsNumeric(String inputAmount) {
-    try {
-      Integer.parseInt(inputAmount);
-    } catch (NumberFormatException e) {
-      throw new IllegalArgumentException("[ERROR] 구입금액은 숫자여야합니다.");
-    }
+  public PurchaseAmount(int inputAmount) {
+    validatePurchaseAmount(inputAmount);
+    this.purchaseAmount = inputAmount;
   }
 
   private void validatePurchaseAmount(int inputAmount) {
     if (inputAmount % LOTTO_PRICE != 0) {
-      throw new IllegalArgumentException("[ERROR] 1000 단위의 금액을 입력하세요.");
+      throw new IllegalArgumentException(ErrorMessage.NOT_A_UNIT_OF_1000.getMessage());
     }
   }
 
-  public int getAmount() {
-    return amount;
+  public int getPurchaseAmount() {
+    return purchaseAmount;
   }
 }

src/main/java/lotto/domain/UserInputNumbers.java

@@ -7,6 +7,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import lotto.util.ErrorMessage;
 
 public class UserInputNumbers {
 
@@ -22,28 +23,28 @@ public UserInputNumbers(List<Integer> receivedLottoNumbers, int bonusNumber) {
 
   private void validateLottoNumbers(List<Integer> receivedLottoNumbers) {
     if (receivedLottoNumbers.size() != SIZE_OF_LOTTO) {
-      throw new IllegalArgumentException("[ERROR] 로또 번호는 총 6개여야 합니다.");
+      throw new IllegalArgumentException(ErrorMessage.NOT_SIX_NUMBERS.getMessage());
     }
 
     for (int number : receivedLottoNumbers) {
       if (number < MIN_LOTTO_NUMBER || number > MAX_LOTTO_NUMBER) {
-        throw new IllegalArgumentException("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+        throw new IllegalArgumentException(ErrorMessage.NOT_IN_RANGE.getMessage());
       }
     }
 
     Set<Integer> uniqueNumbers = new HashSet<>(receivedLottoNumbers);
     if (uniqueNumbers.size() < receivedLottoNumbers.size()) {
-      throw new IllegalArgumentException("[ERROR] 로또 번호는 중복이 없어야 합니다.");
+      throw new IllegalArgumentException(ErrorMessage.MUST_NOT_DUPLICATE.getMessage());
     }
   }
 
   private void validateBonusNumbers(int bonusNumber) {
     if (bonusNumber < MIN_LOTTO_NUMBER || bonusNumber > MAX_LOTTO_NUMBER) {
-      throw new IllegalArgumentException("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+      throw new IllegalArgumentException(ErrorMessage.NOT_IN_RANGE.getMessage());
     }
 
     if (new HashSet<>(receivedLottoNumbers).contains(bonusNumber)) {
-      throw new IllegalArgumentException("[ERROR] 로또 번호는 중복이 없어야 합니다.");
+      throw new IllegalArgumentException(ErrorMessage.MUST_NOT_DUPLICATE.getMessage());
     }
   }
 

src/main/java/lotto/service/LottoGenerator.java

@@ -14,7 +14,7 @@
 public class LottoGenerator {
 
   public static List<Lotto> generateLottos(PurchaseAmount purchaseAmount) {
-    int numberOfLotto = purchaseAmount.getAmount() / LOTTO_PRICE;
+    int numberOfLotto = purchaseAmount.getPurchaseAmount() / LOTTO_PRICE;
     System.out.println("\n" + numberOfLotto + "개를 구매했습니다.");
 
     List<Lotto> generatedLottos = new ArrayList<>();

src/main/java/lotto/service/LottoProfitRateCalculator.java

@@ -15,7 +15,7 @@ public double calculateProfitRate(PurchaseAmount purchaseAmount,
         .mapToInt(entry -> entry.getKey().getPrizeAmount() * entry.getValue())
         .sum();
 
-    double profitRate = (totalPrize / purchaseAmount.getAmount()) * PERCENTAGE_FACTOR;
+    double profitRate = (totalPrize / purchaseAmount.getPurchaseAmount()) * PERCENTAGE_FACTOR;
     DecimalFormat df = new DecimalFormat("#.##");
     return Double.parseDouble(df.format(profitRate));
   }

src/main/java/lotto/util/ErrorMessage.java

@@ -0,0 +1,20 @@
+package lotto.util;
+
+public enum ErrorMessage {
+  NOT_A_NUMBER("[ERROR] 숫자여야 합니다."),
+  NOT_A_SINGLE_NUMBER("[ERROR] 보너스 번호는 하나의 숫자여야 합니다."),
+  NOT_A_UNIT_OF_1000("[ERROR] 1000 단위의 금액이어야 합니다."),
+  NOT_SIX_NUMBERS("[ERROR] 로또 번호는 총 6개여야 합니다."),
+  NOT_IN_RANGE("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다."),
+  MUST_NOT_DUPLICATE("[ERROR] 로또 번호는 중복이 없어야 합니다.");
+
+  private final String message;
+
+  ErrorMessage(String message) {
+    this.message = message;
+  }
+
+  public String getMessage() {
+    return message;
+  }
+}

src/main/java/lotto/util/InputManager.java

@@ -12,34 +12,48 @@ public PurchaseAmount receivePurchaseAmount() {
     while (true) {
       try {
         System.out.println("구입금액을 입력해 주세요.");
-        String input = Console.readLine();
-        return new PurchaseAmount(input);
+        int inputAmount = Integer.parseInt(Console.readLine().trim());
+        return new PurchaseAmount(inputAmount);
+      } catch (NumberFormatException e) {
+        System.out.println(ErrorMessage.NOT_A_NUMBER.getMessage());
       } catch (IllegalArgumentException e) {
         System.out.println(e.getMessage());
       }
     }
   }
 
-
   public UserInputNumbers receiveLottoNumber() {
     while (true) {
-      System.out.println("\n당첨 번호를 입력해 주세요.");
-      String inputNumbers = Console.readLine();
       try {
-        String[] separatedNumbers = inputNumbers.split(",");
-        List<Integer> receivedLottoNumbers = Arrays.stream(separatedNumbers)
-            .map(String::trim)
-            .map(Integer::parseInt)
-            .toList();
-        System.out.println("\n보너스 번호를 입력해 주세요.");
-        int bonusNumber = Integer.parseInt(Console.readLine().trim());
-
+        List<Integer> receivedLottoNumbers = receiveLottoNumbers();
+        int bonusNumber = receiveBonusNumber();
         return new UserInputNumbers(receivedLottoNumbers, bonusNumber);
-      } catch (NumberFormatException e) {
-        System.out.println("[ERROR] 보너스 번호는 1개여야 합니다."); // 하나가 아니라면 String으로 인식
       } catch (IllegalArgumentException e) {
         System.out.println(e.getMessage());
       }
     }
   }
+
+  private List<Integer> receiveLottoNumbers() {
+    try {
+      System.out.println("\n당첨 번호를 입력해 주세요.");
+      String inputNumbers = Console.readLine();
+      String[] separatedNumbers = inputNumbers.split(",");
+      return Arrays.stream(separatedNumbers)
+          .map(String::trim)
+          .map(Integer::parseInt)
+          .toList();
+    } catch (NumberFormatException e) {
+      throw new IllegalArgumentException(ErrorMessage.NOT_A_NUMBER.getMessage());
+    }
+  }
+
+  private int receiveBonusNumber() {
+    try {
+      System.out.println("\n보너스 번호를 입력해 주세요.");
+      return Integer.parseInt(Console.readLine().trim());
+    } catch (NumberFormatException e) {
+      throw new IllegalArgumentException(ErrorMessage.NOT_A_SINGLE_NUMBER.getMessage());
+    }
+  }
 }

src/test/java/lotto/domain/LottoTest.java

@@ -0,0 +1,59 @@
+package lotto.domain;
+
+import java.util.Arrays;
+import lotto.domain.Lotto;
+import lotto.domain.UserInputNumbers;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+class LottoTest {
+
+  @DisplayName("로또 번호의 개수가 6개가 넘어가면 예외가 발생한다.")
+  @Test
+  void createLottoByOverSize() {
+    assertThatThrownBy(() -> new Lotto(List.of(1, 2, 3, 4, 5, 6, 7)))
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
+  @DisplayName("로또 번호의 범위가 1~45가 아닌 경우 예외가 발생한다.")
+  @Test
+  void createLottoByInvalidNumber() {
+    assertThatThrownBy(() -> new Lotto(List.of(0, 2, 3, 4, 5, 6)))
+        .isInstanceOf(IllegalArgumentException.class);
+    assertThatThrownBy(() -> new Lotto(List.of(1, 2, 3, 4, 5, 46)))
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
+  @DisplayName("로또 번호에 중복된 숫자가 있는 경우 예외가 발생한다.")
+  @Test
+  void createLottoByDuplicatedNumber() {
+    // TODO: 이 테스트가 통과할 수 있게 구현 코드 작성
+    assertThatThrownBy(() -> new Lotto(List.of(1, 2, 3, 4, 5, 5)))
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
+  @DisplayName("getMatchCount()는 로또 번호와 일치하는 번호의 수를 반환한다.")
+  @Test
+  void testGetMatchCount() {
+    List<Integer> lottoNumbers = Arrays.asList(1, 2, 3, 4, 5, 6);
+    Lotto lotto = new Lotto(lottoNumbers);
+    UserInputNumbers userInputNumbers = new UserInputNumbers(lottoNumbers, 7);
+    int matchCount = lotto.getMatchCount(userInputNumbers);
+    assertThat(matchCount).isEqualTo(6);
+  }
+
+  @DisplayName("isBonusMatch()는 로또 번호와 보너스 번호가 일치하면 true를 반환한다.")
+  @Test
+  void testIsBonusMatch() {
+    List<Integer> lottoNumbers = Arrays.asList(1, 2, 3, 4, 5, 6);
+    Lotto lotto = new Lotto(lottoNumbers);
+    UserInputNumbers userInputNumbers = new UserInputNumbers(lottoNumbers, 7);
+    boolean isBonusMatch = lotto.isBonusMatch(userInputNumbers);
+    assertThat(isBonusMatch).isFalse(); // 보너스 번호는 7이므로 일치하지 않아야 함
+  }
+}

src/test/java/lotto/domain/PurchaseAmountTest.java

@@ -0,0 +1,16 @@
+package lotto.domain;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class PurchaseAmountTest {
+
+  @DisplayName("구입금액이 1000 단위가 아니라면 예외가 발생한다.")
+  @Test
+  void createPurchaseAmountByInvalidAmount() {
+    assertThatThrownBy(() -> new PurchaseAmount(1500))
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+}

src/test/java/lotto/domain/UserInputNumbersTest.java

@@ -0,0 +1,33 @@
+package lotto.domain;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
+
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class UserInputNumbersTest {
+
+  @DisplayName("당첨 번호의 개수가 6개를 넘어가는 경우 예외가 발생한다.")
+  @Test
+  void createNumberByOverSize() {
+    assertThatThrownBy(() -> new UserInputNumbers(List.of(1, 2, 3, 4, 5, 6, 7), 8))
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
+  @DisplayName("당첨 번호의 범위가 1~45가 아닌 경우 예외가 발생한다.")
+  @Test
+  void createNumberByInvalidNumber() {
+    assertThatThrownBy(() -> new UserInputNumbers(List.of(0, 2, 3, 4, 5, 6), 7))
+        .isInstanceOf(IllegalArgumentException.class);
+    assertThatThrownBy(() -> new UserInputNumbers(List.of(1, 2, 3, 4, 5, 46), 7))
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
+  @DisplayName("당첨 번호에 중복된 숫자가 있는 경우 예외가 발생한다.")
+  @Test
+  void createNumberByDuplicatedNumber() {
+    assertThatThrownBy(() -> new UserInputNumbers(List.of(1, 2, 3, 4, 5, 5), 7))
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+}