[1단계 - 블랙잭] 후디(조동현) 미션 제출합니다.

src/main/java/blackjack/domain/card/CardBundle.java → src/main/java/blackjack/domain/card/Hand.java

@@ -6,18 +6,18 @@
 import java.util.function.Function;
 
 // TODO: 클래스명 변경
-public class CardBundle {
+public class Hand {
     private static final String NO_DUPLICATE_CARD_EXCEPTION_MESSAGE = "중복된 카드는 존재할 수 없습니다.";
 
     private final Set<Card> cards;
 
-    private CardBundle(Set<Card> cards) {
+    private Hand(Set<Card> cards) {
         this.cards = cards;
     }
 
-    public static CardBundle of(Card card1, Card card2) {
+    public static Hand of(Card card1, Card card2) {
         Set<Card> initialCards = new HashSet<>(Set.of(card1, card2));
-        return new CardBundle(initialCards);
+        return new Hand(initialCards);
     }
 
     public void add(Card card) {
@@ -60,6 +60,8 @@ private Score getMinimumScore(Card card) {
 
     @Override
     public String toString() {
-        return "CardBundle{" + "cards=" + cards + '}';
+        return "Hand{" +
+                "cards=" + cards +
+                '}';
     }
 }

src/main/java/blackjack/domain/game/BlackjackGame.java

@@ -1,8 +1,8 @@
 package blackjack.domain.game;
 
 import blackjack.domain.card.Card;
-import blackjack.domain.card.CardBundle;
 import blackjack.domain.card.CardStack;
+import blackjack.domain.card.Hand;
 import blackjack.domain.participant.Dealer;
 import blackjack.domain.participant.Player;
 import java.util.ArrayList;
@@ -21,13 +21,13 @@ public BlackjackGame(CardStack cardDeck, List<String> playerNames) {
         validatePlayerNames(playerNames);
 
         this.cardDeck = cardDeck;
-        this.dealer = Dealer.of(initializeCardBundle());
+        this.dealer = Dealer.of(initializeHand());
         participants.addAll(initializePlayers(playerNames));
     }
 
     private List<Player> initializePlayers(List<String> playerNames) {
         return playerNames.stream()
-                .map(name -> Player.of(name, initializeCardBundle()))
+                .map(name -> Player.of(name, initializeHand()))
                 .collect(Collectors.toList());
     }
 
@@ -58,8 +58,8 @@ public List<Player> getParticipants() {
         return participants;
     }
 
-    private CardBundle initializeCardBundle() {
-        return CardBundle.of(cardDeck.pop(), cardDeck.pop());
+    private Hand initializeHand() {
+        return Hand.of(cardDeck.pop(), cardDeck.pop());
     }
 
     @Override

src/main/java/blackjack/domain/participant/Dealer.java

@@ -1,7 +1,7 @@
 package blackjack.domain.participant;
 
 import blackjack.domain.card.Card;
-import blackjack.domain.card.CardBundle;
+import blackjack.domain.card.Hand;
 import blackjack.domain.game.Score;
 
 public class Dealer extends Participant {
@@ -10,33 +10,33 @@ public class Dealer extends Participant {
     private static final String DEALER_NAME = "딜러";
     private static final String INVALID_CARD_QUANTITY_EXCEPTION_MESSAGE = "딜러는 최대 3개의 카드만 지닐 수 있습니다.";
 
-    private Dealer(final String name, final CardBundle cardBundle) {
-        super(name, cardBundle);
+    private Dealer(final String name, final Hand hand) {
+        super(name, hand);
     }
 
-    public static Dealer of(final CardBundle cardBundle) {
-        return new Dealer(DEALER_NAME, cardBundle);
+    public static Dealer of(final Hand hand) {
+        return new Dealer(DEALER_NAME, hand);
     }
 
     public void receiveCard(Card card) {
         validateCardQuantity();
-        cardBundle.add(card);
+        hand.add(card);
     }
 
     private void validateCardQuantity() {
-        if (cardBundle.getCards().size() >= MAXIMUM_CARDS_QUANTITY) {
+        if (hand.getCards().size() >= MAXIMUM_CARDS_QUANTITY) {
             throw new IllegalArgumentException(INVALID_CARD_QUANTITY_EXCEPTION_MESSAGE);
         }
     }
 
     public boolean canReceive() {
-        Score score = cardBundle.getScore();
+        Score score = hand.getScore();
         return score.toInt() <= Score.DEALER_EXTRA_CARD_LIMIT;
     }
 
     // TODO: handle NPE
     public Card getOpenCard() {
-        return cardBundle.getCards()
+        return hand.getCards()
                 .stream()
                 .findFirst()
                 .get();
@@ -46,7 +46,7 @@ public Card getOpenCard() {
     public String toString() {
         return "Dealer{" +
                 "name='" + name + '\'' +
-                ", cardBundle=" + cardBundle +
+                ", hand=" + hand +
                 '}';
     }
 }

src/main/java/blackjack/domain/participant/Participant.java

@@ -1,38 +1,38 @@
 package blackjack.domain.participant;
 
 import blackjack.domain.card.Card;
-import blackjack.domain.card.CardBundle;
+import blackjack.domain.card.Hand;
 import blackjack.domain.game.ResultType;
 import blackjack.domain.game.Score;
 
 public abstract class Participant {
 
     protected final String name;
-    protected CardBundle cardBundle;
+    protected Hand hand;
 
-    protected Participant(final String name, final CardBundle cardBundle) {
+    protected Participant(final String name, final Hand hand) {
         this.name = name;
-        this.cardBundle = cardBundle;
+        this.hand = hand;
     }
 
     public abstract void receiveCard(Card card);
 
     public abstract boolean canReceive();
 
     public Score getCurrentScore() {
-        return cardBundle.getScore();
+        return hand.getScore();
     }
 
     public String getName() {
         return name;
     }
 
-    public CardBundle getCardBundle() {
-        return cardBundle;
+    public Hand getHand() {
+        return hand;
     }
 
     public boolean isBusted() {
-        return cardBundle.getScore().toInt() > Score.BLACKJACK;
+        return hand.getScore().toInt() > Score.BLACKJACK;
     }
 
     public ResultType compareWith(Participant other) {

src/main/java/blackjack/domain/participant/Player.java

@@ -1,33 +1,33 @@
 package blackjack.domain.participant;
 
 import blackjack.domain.card.Card;
-import blackjack.domain.card.CardBundle;
+import blackjack.domain.card.Hand;
 import blackjack.domain.game.Score;
 
 public class Player extends Participant {
 
-    private Player(final String name, final CardBundle cardBundle) {
-        super(name, cardBundle);
+    private Player(final String name, final Hand hand) {
+        super(name, hand);
     }
 
-    public static Player of(final String name, final CardBundle cardBundle) {
-        return new Player(name, cardBundle);
+    public static Player of(final String name, final Hand hand) {
+        return new Player(name, hand);
     }
 
     public void receiveCard(Card card) {
-        cardBundle.add(card);
+        hand.add(card);
     }
 
     public boolean canReceive() {
-        Score score = cardBundle.getScore();
+        Score score = hand.getScore();
         return score.toInt() <= Score.BLACKJACK;
     }
 
     @Override
     public String toString() {
         return "Player{" +
                 "name='" + name + '\'' +
-                ", cardBundle=" + cardBundle +
+                ", hand=" + hand +
                 '}';
     }
 }

src/main/java/blackjack/dto/HandDto.java

@@ -22,7 +22,7 @@ public static HandDto of(Participant participant) {
     }
 
     private static List<String> getCards(Participant participant) {
-        return participant.getCardBundle()
+        return participant.getHand()
                 .getCards()
                 .stream()
                 .map(Card::getName)

src/test/java/blackjack/domain/card/CardBundleTest.java → src/test/java/blackjack/domain/card/HandTest.java

@@ -10,43 +10,43 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
-public class CardBundleTest {
+public class HandTest {
 
-    @DisplayName("of 팩토리 메소드는 두개의 카드를 받아 CardBundle 인스턴스를 생성한다.")
+    @DisplayName("of 팩토리 메소드는 두개의 카드를 받아 Hand 인스턴스를 생성한다.")
     @Test
-    void of_initsNewCardBundleWithTwoCards() {
+    void of_initsNewHandWithTwoCards() {
         CardDeck cardDeck = new CardDeck();
-        CardBundle cardBundle = CardBundle.of(cardDeck.pop(), cardDeck.pop());
+        Hand hand = Hand.of(cardDeck.pop(), cardDeck.pop());
 
-        assertThat(cardBundle).isNotNull();
+        assertThat(hand).isNotNull();
     }
 
     @DisplayName("add 메서드로 새로운 카드를 추가할 수 있다.")
     @Test
     void add() {
-        CardBundle cardBundle = CardBundle.of(CLOVER4, CLOVER5);
-        cardBundle.add(CLOVER6);
+        Hand hand = Hand.of(CLOVER4, CLOVER5);
+        hand.add(CLOVER6);
 
-        assertThat(cardBundle.getCards())
+        assertThat(hand.getCards())
                 .contains(CLOVER4, CLOVER5, CLOVER6);
     }
 
     @DisplayName("add 메서드로 중복된 카드를 추가하려고 하면 예외가 발생한다.")
     @Test
     void add_throwsExceptionOnDuplicateCard() {
-        CardBundle cardBundle = CardBundle.of(CLOVER4, CLOVER5);
+        Hand hand = Hand.of(CLOVER4, CLOVER5);
 
         assertThatExceptionOfType(RuntimeException.class)
-                .isThrownBy(() -> cardBundle.add(CLOVER5))
+                .isThrownBy(() -> hand.add(CLOVER5))
                 .withMessage("중복된 카드는 존재할 수 없습니다.");
     }
 
     @DisplayName("getScore 는 각 카드가 지닌 값들의 합을 합산하여 반환한다.")
     @Test
     void getScore() {
-        CardBundle cardBundle = CardBundle.of(CLOVER4, CLOVER5);
+        Hand hand = Hand.of(CLOVER4, CLOVER5);
 
-        Score actual = cardBundle.getScore();
+        Score actual = hand.getScore();
         Score expected = Score.valueOf(9);
 
         assertThat(actual).isEqualTo(expected);

src/test/java/blackjack/domain/game/RefereeTest.java

@@ -6,7 +6,7 @@
 import static blackjack.domain.fixture.CardRepository.CLOVER9;
 import static org.assertj.core.api.Assertions.assertThat;
 
-import blackjack.domain.card.CardBundle;
+import blackjack.domain.card.Hand;
 import blackjack.domain.participant.Dealer;
 import blackjack.domain.participant.Player;
 import java.util.Map;
@@ -21,9 +21,9 @@ public class RefereeTest {
     void generateDealerResult() {
         // given
         Referee referee = new Referee();
-        Dealer dealer = Dealer.of(CardBundle.of(CLOVER9, CLOVER7));
-        Player winnerPlayer = Player.of("winner", CardBundle.of(CLOVER10, CLOVER7));
-        Player loserPlayer = Player.of("loser", CardBundle.of(CLOVER8, CLOVER7));
+        Dealer dealer = Dealer.of(Hand.of(CLOVER9, CLOVER7));
+        Player winnerPlayer = Player.of("winner", Hand.of(CLOVER10, CLOVER7));
+        Player loserPlayer = Player.of("loser", Hand.of(CLOVER8, CLOVER7));
 
         // when
         Map<ResultType, ResultCount> result = referee.generateDealerResult(dealer, Set.of(winnerPlayer, loserPlayer));
@@ -39,8 +39,8 @@ void generateDealerResult() {
     void generatePlayerResult_returnsWin() {
         // given
         Referee referee = new Referee();
-        Player winnerPlayer = Player.of("winner", CardBundle.of(CLOVER10, CLOVER7));
-        Player loserPlayer = Player.of("loser", CardBundle.of(CLOVER8, CLOVER7));
+        Player winnerPlayer = Player.of("winner", Hand.of(CLOVER10, CLOVER7));
+        Player loserPlayer = Player.of("loser", Hand.of(CLOVER8, CLOVER7));
 
         // when
         ResultType actual = referee.generatePlayerResult(winnerPlayer, loserPlayer);
@@ -55,8 +55,8 @@ void generatePlayerResult_returnsWin() {
     void generatePlayerResult_returnsLose() {
         // given
         Referee referee = new Referee();
-        Player winnerPlayer = Player.of("winner", CardBundle.of(CLOVER10, CLOVER7));
-        Player loserPlayer = Player.of("loser", CardBundle.of(CLOVER8, CLOVER7));
+        Player winnerPlayer = Player.of("winner", Hand.of(CLOVER10, CLOVER7));
+        Player loserPlayer = Player.of("loser", Hand.of(CLOVER8, CLOVER7));
 
         // when
         ResultType actual = referee.generatePlayerResult(loserPlayer, winnerPlayer);
@@ -71,8 +71,8 @@ void generatePlayerResult_returnsLose() {
     void generatePlayerResult_returnsDraw() {
         // given
         Referee referee = new Referee();
-        Player player1 = Player.of("winner", CardBundle.of(CLOVER10, CLOVER7));
-        Player player2 = Player.of("loser", CardBundle.of(CLOVER9, CLOVER8));
+        Player player1 = Player.of("winner", Hand.of(CLOVER10, CLOVER7));
+        Player player2 = Player.of("loser", Hand.of(CLOVER9, CLOVER8));
 
         // when
         ResultType actual = referee.generatePlayerResult(player1, player2);