Ejemplo n.º 1
0
class DeckTests(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()

    def test_init(self):
        '''Creates the deck'''
        self.assertEqual(repr(self.deck), 'Deck of 52 cards')

    def test_count(self):
        '''Deck should have 52 cards'''
        self.assertEqual(self.deck.count(), 52)

    def test_shuffle_full_deck(self):
        '''Shuffles the deck full deck'''
        initial_cards = self.deck.cards[:]
        self.deck.shuffle()

        self.assertNotEqual(initial_cards, self.deck.cards)
        self.assertEqual(len(initial_cards), len(self.deck.cards))

    def test_shuffle_not_full_deck(self):
        '''Cannot shuffle a deck that's not full'''
        self.deck._deal(1)

        with self.assertRaises(ValueError):
            self.deck.shuffle()

    def test_deal_card(self):
        '''Deals a card'''
        self.assertIsInstance(self.deck.deal_card(), Card)
Ejemplo n.º 2
0
def lucky_card():
    d = Deck()
    d.shuffle()
    try:
        user = input("Hello! What's your name? ")
        deal_amount = int(input(f"How many random cards would you like to be dealt {user}? "))
        if deal_amount >= 53:
            print("There are only 52 cards in a deck!")
        elif deal_amount == 1:
            print(f"Here is your lucky card {user} ", d._deal(deal_amount))
        elif deal_amount <= 1:
            print("You have to enter positive number, there isn't a negative suit.")
        elif 52 >= deal_amount > 1:
            print(f"Here are your {deal_amount} lucky cards {user}", d._deal(deal_amount))
    except ValueError:
        print("Next Time Enter a Number!")
Ejemplo n.º 3
0
class DeckTest(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()

    def test_init(self):
        self.assertEqual(type(self.deck.suits), list)
        self.assertEqual(type(self.deck.values), list)
        self.assertEqual(type(self.deck.cards[0]), Card)

    def test_repr(self):
        self.assertEqual(repr(self.deck), f"Deck of {self.deck.count()} cards")

    def test_count(self):
        self.assertEqual(self.deck.count(), 52)
        self.deck.cards.pop()
        self.assertEqual(self.deck.count(), 51)
        self.deck = Deck()
        hand = self.deck._deal(53)
        self.assertTrue(hand)
        self.assertEqual(type(hand), list)
        self.assertEqual(len(hand), 52)
        self.assertEqual(self.deck.count(), 0)

    def test_deal(self):
        self.assertEqual(type(self.deck._deal(1)), list)
        self.assertEqual(self.deck.count(), 51)

    def test_deal_card(self):
        self.assertEqual(type(self.deck.deal_card()), Card)
        self.assertEqual(self.deck.count(), 51)

    def test_deal_hand(self):
        self.assertEqual(type(self.deck.deal_hand(5)), list)
        self.assertEqual(self.deck.count(), 47)
        self.assertEqual(type(self.deck.deal_hand(5)[0]), Card)

    def test_shuffle(self):
        deck_cpy = self.deck.cards[:]
        self.assertEqual(self.deck.cards, deck_cpy)
        self.deck.shuffle()
        self.assertNotEqual(self.deck, deck_cpy)
        self.assertEqual(self.deck.count(), 52)
        self.deck.deal_hand(5)
        with self.assertRaises(ValueError):
            self.deck.shuffle()
Ejemplo n.º 4
0
class DeckTests(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()

    def test_init(self):
        self.assertTrue(isinstance(self.deck.cards, list))
        self.assertEqual(len(self.deck.cards), 52)

    def test_repr(self):
        self.assertEqual(repr(self.deck), "Deck of 52 cards")

    def test_count(self):
        self.assertEqual(self.deck.count(), 52)
        self.deck.cards.pop()
        self.assertEqual(self.deck.count(), 51)

    def test_deal_sufficient_amount_of_cards(self):
        cards = self.deck._deal(10)
        self.assertEqual(len(cards), 10)
        self.assertEqual(self.deck.count(), 42)

    def test_insufficient_amount_of_cards(self):
        cards = self.deck._deal(100)
        self.assertEqual(len(cards), 52)
        self.assertEqual(self.deck.count(), 0)

    def test_deal_no_cards(self):
        self.deck._deal(self.deck.count())
        with self.assertRaises(ValueError):
            self.deck._deal(1)

    def test_deal_card(self):
        card = self.deck.cards[-1]
        dealt_card = self.deck.deal_card()
        self.assertEqual(card, dealt_card)
        self.assertEqual(self.deck.count(), 51)

    def test_deal_cards(self):
        cards = self.deck.deal_hand(20)
        self.assertEqual(len(cards), 20)
        self.assertEqual(self.deck.count(), 32)

    def test_shuffle_full_deck(self):
        cards = self.deck.cards[:]
        self.deck.shuffle()
        self.assertNotEqual(cards, self.deck.cards)
        self.assertEqual(self.deck.count(), 52)

    def test_shuffle_not_full_deck(self):
        self.deck._deal(1)
        with self.assertRaises(ValueError):
            self.deck.shuffle()
Ejemplo n.º 5
0
class TestDeck(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()

    def test_init(self):
        self.assertIsInstance(self.deck.cards, list)

    def test_count(self):
        self.assertEqual(len(self.deck.cards), 52)
        self.deck.cards.pop()
        self.assertEqual(len(self.deck.cards), 51)

    def test_repr(self):
        self.assertEqual(repr(self.deck), 'Deck of 52 cards')

    def test_deal_some(self):
        cards = self.deck._deal(5)
        self.assertEqual(len(cards), 5)
        self.assertEqual(self.deck.count(), 47)

    def test_deal_all(self):
        cards = self.deck._deal(60)
        self.assertEqual(len(cards), 52)
        self.assertEqual(self.deck.count(), 0)

    def test_deal_no_cards(self):
        self.deck._deal(52)
        with self.assertRaises(ValueError):
            self.deck._deal(1)

    def test_deal_cards(self):
        card = self.deck.cards[-1]
        dealt_card = self.deck.deal_card()
        self.assertEqual(card, dealt_card)
        self.assertEqual(self.deck.count(), 51)

    def test_deal_hand(self):
        cards = self.deck.deal_hand(12)
        self.assertEqual(len(cards), 12)
        self.assertEqual(self.deck.count(), 40)

    def test_shuffle_unsufficient(self):
        self.deck._deal(10)
        self.assertEqual(self.deck.count(), 42)
        with self.assertRaises(ValueError):
            self.deck.shuffle()

    def test_shuffle_sufficient(self):
        clone_cards = self.deck.cards[:]
        self.deck.shuffle()
        self.assertEqual(self.deck.count(), 52)
        self.assertNotEqual(clone_cards, self.deck.cards)
Ejemplo n.º 6
0
class TestDeck(unittest.TestCase):
    def setUp(self):
        self.d1 = Deck()

    def test_init(self):
        """ decks should be card attribute, has 52 cards """
        self.assertTrue(isinstance(self.d1.cards, list))
        self.assertEqual(len(self.d1.cards), 52)

    def test_repr(self):
        """ test repr of duck !"""
        self.assertEqual(repr(self.d1), "Deck of 52 cards")

    def test_count(self):
        """ count how many card left has deck """
        self.assertEqual(self.d1.count(), 52)
        self.d1.cards.pop()
        self.assertEqual(self.d1.count(), 51)

    def test_deal_sufficient_card(self):
        """ check sufficient card has on the deck """
        self.assertEqual(len(self.d1._deal(10)), 10)
        self.assertEqual(len(self.d1._deal(42)), 42)

    def test_deal_insufficient_card(self):
        """ check insufficient card has on the deck """
        self.assertEqual(len(self.d1._deal(100)), 52)
        with self.assertRaises(ValueError):
            self.d1._deal(52)
        self.assertEqual(len(self.d1.cards), 0)

    def test_deal_cards(self):
        """test deal cards with the last card"""
        last_card = self.d1.cards[-1]
        deal_card = self.d1.deal_card()
        self.assertEqual(last_card, deal_card)
        self.assertEqual(self.d1.count(), 51)

    def test_deal_hand(self):
        """test deal hand with removing cards"""
        self.assertEqual(len(self.d1.deal_hand(52)), 52)
        with self.assertRaises(ValueError):
            self.d1.deal_hand(10)

    def test_shuffle_with_full_deck(self):
        cards = self.d1.cards[:]
        self.d1.shuffle()
        self.assertNotEqual(cards, self.d1.cards)
        self.assertEqual(len(cards), len(self.d1.cards))

    def test_shuffle_with_no_full_deck(self):
        self.d1._deal(1)
        with self.assertRaises(ValueError):
            self.d1.shuffle()
class DeckTests(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()

    def test_init(self):
        self.assertTrue(isinstance(self.deck.cards, list))
        self.assertEqual(len(self.deck.cards), 52)

    def test_repr(self):
        self.assertEqual(repr(self.deck), "Deck of 52 cards")

    def test_count(self):
        self.assertEqual(self.deck.count(), 52)
        self.deck.cards.pop()
        self.assertEqual(self.deck.count(), 51)

    def test_deal_sufficient_cards(self):
        cards = self.deck._deal(100)
        self.assertEqual(len(cards), 52)
        self.assertEqual(self.deck.count(), 0)
Ejemplo n.º 8
0
class DeckTests(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()

    def test_init(self):
        """__init__ should create a deck/list of 52 cards"""
        self.assertEqual(len(self.deck.cards), 52)
        self.assertIsInstance(self.deck.cards, list)
        # Colt's
        # self.assertTrue(isinstance(self.deck.cards, list))

    def test_repr(self):
        """__repr__ returns 'Deck of {self.count()} cards'"""
        self.assertEqual(repr(self.deck), "Deck of 52 cards")

    def test_reset(self):
        """Should reset back to init state"""
        self.assertEqual(self.deck, self.deck.reset())

    def test_shuffle_insufficient(self):
        """Only shuffle decks of 52 cards"""
        # How to properly call shuffle()? Deck.shuffle()? self.deck.shuffle(self.deck.cards)?
        # self.assertSequenceEqual(self.deck.cards, Deck.shuffle(self.deck.cards))
        # Keep getting != <bound method Deck.shffle of Deck of 52 cards>

        # Broken: self.assertEqual(self.deck.cards[0:5], self.deck.shuffle())
        self.deck.deal_card()
        with self.assertRaises(ValueError):
            # Deck.shuffle(self.deck)
            self.deck.shuffle()

    # Colt's shuffle full deck solution
    def test_shuffle_full_deck(self):
        """shuffle should shuffle the deck if the deck is full"""
        cards = self.deck.cards[:]  # A way to copy original state
        self.deck.shuffle()
        self.assertNotEqual(cards, self.deck.cards)
        self.assertEqual(self.deck.count(),
                         52)  # This is key since [] != full deck

    # Colt tested the _deal method directly. Here's his tests:
    def test_deal_sufficient_cards(self):
        """_deal should deal the number of cards specified"""
        cards = self.deck._deal(10)
        self.assertEqual(len(cards), 10)
        self.assertEqual(self.deck.count(), 42)

    # Colt's. Similar to my _insufficient below
    def test_deal_insufficient_cards(self):
        """_deal should deal the number of cards left in the deck"""
        cards = self.deck._deal(100)
        self.assertEqual(len(cards), 52)
        self.assertEqual(self.deck.count(), 0)

    # Colt's test for ValueError
    def test_deal_no_cards(self):
        """_deal should throw a ValueError if the deck is empty"""
        self.deck._deal(
            self.deck.count())  # clever way to deal all/empty the deck
        with self.assertRaises(ValueError):
            self.deck._deal(1)

    def test_deal_card_insufficient(self):
        """Should deal all remaining cards or raise ValueError when zero cards left"""
        # First dealing out all cards.
        self.assertEqual(self.deck.cards[-self.deck.count()::],
                         self.deck.deal_hand(53)[::-1])
        # Then trying to deal single card when no cards left (self.deck.count() = 0)
        with self.assertRaises(ValueError):
            self.deck.deal_card()

    def test_deal_card(self):
        """Subtracts 1 card from deck and returns card instance"""
        # swap order so [-1] gets retrieved before deal pops() card
        # if going to call deal_card() directly, need to place at top to get count of 51
        self.deck.deal_card()
        self.assertEqual(self.deck.count(), 51)
        self.assertEqual(self.deck.cards[-1], self.deck.deal_card())
        # if using assertNotIn, can I just use self.deck? Seems that way...
        self.assertNotIn(
            self.deck.deal_card(),
            self.deck,
            msg="Once dealt, the card shouldn't be in original deck")
        # Colt's solution. Nice use of variables (card and dealt_card)
        # card = self.deck.cards[-1]
        # dealt_card = self.deck.deal_card()
        # self.assertEqual(card, dealt_card)
        # self.assertEqual(self.deck.count(), 51)

    def test_deal_hand(self):
        """Cards should be dealt from the top (end) of the deck"""
        self.assertEqual(self.deck.cards[-6::], self.deck.deal_hand(6)[::-1])
        # Colt's solution.
        # cards = self.deck.deal_hand(20)
        # self.assertEqual(len(cards), 20)
        # self.assertEqual(self.deck.count(), 32)

    def test_count(self):
        """Return the number of cards in Deck.cards"""
        self.assertEqual(self.deck.count(), 52)
        self.deck.deal_hand(10)
        # Colt's using pop() then checking count() = 51
        # self.deck.cards.pop()
        self.assertEqual(self.deck.count(), 42)
Ejemplo n.º 9
0
class DeckTests(unittest.TestCase):
        def setUp(self):
            self.deck = Deck()
            #setup sets deck to the full deck through Deck()
            #runs before every test case
            
        def test_init(self):
            """decks should have a cards attribute, which is a list of 52 items"""
            #doesn't test if all 52 items are cards, just that there are 52 things in this list
            self.assertTrue(isinstance(self.deck.cards, list))
            self.assertEqual(len(self.deck.cards), 52)

        def test_repr(self):
            """should print out deck of 52 cards"""
            self.assertEqual(repr(self.deck), 'Deck of 52 cards')
            
            
        def test_count(self):
            """count of deck should be 52 cards and should be 51 after running a pop"""
            self.assertEqual(self.deck.count(), 52)
            self.deck.cards.pop()
            self.assertEqual(self.deck.count(), 51)
            
        
        def test_deal_sufficient_cards(self):
            """should print out message on _deal() when there is enough cards to deal"""
            cards = self.deck._deal(10)
            self.assertEqual(len(cards), 10)
            self.assertEqual(self.deck.count(), 42)

        def test_deal_insufficient_cards(self):
            """should deal the remaining cards in the deck"""
            cards = self.deck._deal(100)
            self.assertEqual(len(cards), 52)
            self.assertEqual(self.deck.count(), 0)

        def test_deal_no_cards(self):
            """_deal should throw ValueErrorif the deck is empty when calling _deal"""
            #first line deals the entire deck self.deck.count() is 52 so we deal 52
            self.deck._deal(self.deck.count())
            #raises ValueError when 1 card id dealt when the deck is empty
            with self.assertRaises(ValueError):
                self.deck._deal(1)

        def test_deal_card(self):
            """deal_card should remove a single card from the deck"""
            #card will be the last card in the deck
            card = self.deck.cards[-1]
            #self.deck.deal() is also the last card in the deck
            dealt_card = self.deck.deal_card()
            self.assertEqual(card, dealt_card)
            self.assertEqual(self.deck.count(), 51)

        def test_deal_hand(self):
            """deal_hand should deal the number of cards passed in as an argument"""
            cards = self.deck.deal_hand(20)
            self.assertEqual(len(cards), 20)
            self.assertEqual(self.deck.count(), 32)
            
            
        def test_shuffle_full_deck(self):
            """shuffle should shuffle the deck if the deck is full"""
            #sets the cards variable to one instance of the deck
            cards = self.deck.cards[:]
            #shuffles the initial deck (not cards)
            self.deck.shuffle()
            #checks if cards and self.deck.cards are not the same (self.deck.cards has been shuffled
            self.assertNotEqual(cards, self.deck.cards)
            #checks if self.deck contains 52 cards necessary to run shuffle()
            self.assertEqual(self.deck.count(), 52)
            
        def test_shuffle_not_full_deck(self):
            """throws a ValueError when shuffling a not full deck"""
            #deals 1 card from the deck which makes self.deck.count() 51
            self.deck._deal(1)
            #tries shuffling the 51 card deck and raises a valueerror.
            with self.assertRaises(ValueError):
                self.deck.shuffle()
Ejemplo n.º 10
0
class DeckTests(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()

    def test_init(self):
        """decks should have a cards attribute, which is a """
        self.assertTrue(len(self.deck.cards), 52)

    def test_repr(self):
        """repr should return a string of the form 'Deck of 52' cards """
        self.assertEqual(repr(self.deck), "Deck of 52 cards")

    def test_count(self):
        """count should return a count of the number of cards remaining """
        self.assertEqual(self.deck.count(), 52)
        self.deck.deal_card()
        self.assertEqual(self.deck.count(), 51)

    def test_deal_sufficient_cards(self):
        """ _deal should deal the number of cards specified, """
        cards = self.deck._deal(10)
        self.assertEqual(len(cards), 10)
        self.assertEqual(self.deck.count(), 42)

    def test_deal_insufficient_cards(self):
        """ _deal should deal the number of cards remaining """
        cards = self.deck._deal(100)
        self.assertEqual(len(cards), 52)
        self.assertEqual(self.deck.count(), 0)

        def test_deal_no_cards(self):
            """_deal should throw a ValueError if the deck is """
            self.deck._deal(self.deck.count())
            with self.assertRaises(ValueError):
                self.deck._deal(1)

        def test_deal_card(self):
            """deal_card should deal a sinle card from the deck """
            card = self.deck.cards[-1]
            dealt_card = self.deck.deal_card()
            self.assertEqual(card, dealt_card)
            self.assertEqual(self.deck.count(), 51)

        def test_deal_hand(self):
            """ deal_hand should deal the number of cards passed """
            cards = self.deck.deal_hand(20)
            self.assertEqual(len(cards), 20)
            self.assertEqual(self.deck.count(), 32)

        def test_shuffle_full_deck(self):
            """shuffle should shuffle the deck if the deck is """
            cards = self.deck.cards[:]
            self.deck.shuffle()
            self.assertEqual(cards, self.deck.cards)
            self.assertEqual(self.deck.count(), 52)

        def test_shuffle_not_full_deck(self):
            """shuffle should throw a ValueError if the deck is not full """
            self.deck._deal(1)
            with self.assertRaises(ValueError):
                self.deck.shuffle()
Ejemplo n.º 11
0
class DeckTests(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()

    def test_init(self):
        """decks should have a cards attribute, which is a list with 52 cards """
        self.assertTrue(isinstance(self.deck.cards, list))
        self.assertEqual(len(self.deck.cards), 52)

    def test_repr(self):
        """repr should return a string of the form 'Deck of COUNT cards.'"""
        self.assertEqual(repr(self.deck), "Deck of 52 cards")

    def test_count(self):
        """count should return a count of the number of cards in the deck"""
        self.assertEqual(self.deck.count(), 52)
        self.deck.cards.pop()
        self.assertEqual(self.deck.count(), 51)

    def test_deal_sufficient_cards(self):
        """deal should deal the number of cards specified, and the deck count has gone down to all minus dealt cards"""
        cards = self.deck._deal(10)
        self.assertEqual(len(cards), 10)
        self.assertEqual(self.deck.count(), 42)

    def test_deal_insufficient_cards(self):
        """deal should deal the number of cards left in the deck"""
        cards = self.deck._deal(100)
        self.assertEqual(len(cards), 52)
        self.assertEqual(self.deck.count(), 0)

    def test_deal_no_cards(self):
        """deal should throw ValueError if the deck is empty"""
        self.deck._deal(self.deck.count())
        with self.assertRaises(ValueError):
            self.deck._deal(1)

    def test_deal_card(self):
        """deal_card should deal a single card from the deck"""
        card = self.deck.cards[-1]
        dealt_card = self.deck.deal_card()
        self.assertEqual(card, dealt_card)
        self.assertEqual(self.deck.count(), 51)

    def test_deal_hand(self):
        """deal_hand should deal the number of cards passed into it"""
        cards = self.deck.deal_hand(20)
        self.assertEqual(len(cards), 20)
        self.assertEqual(self.deck.count(), 32)

    def test_shuffle_full_deck(self):
        """shuffle should shuffle the deck if the deck is full"""
        cards = self.deck.cards[:]
        self.deck.shuffle()
        self.assertNotEqual(cards, self.deck.cards)
        self.assertEqual(self.deck.count(), 52)

    def test_shuffle_not_full_deck(self):
        """shuffle should throw a ValueError of the deck"""
        self.deck._deal(1)
        with self.assertRaises(ValueError):
            self.deck.shuffle()
Ejemplo n.º 12
0
class DeckTests(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()

    def test_init(self):
        """decks should have a cards list attribute with length 52"""
        self.assertTrue(isinstance(self.deck.cards, list))
        self.assertEqual(len(self.deck.cards), 52)

    def test_repr(self):
        """decks should be represented as 'Deck of COUNT cards'"""
        self.assertEqual(repr(self.deck), "Deck of 52 cards")

    def test_count(self):
        """count should return the number of cards in the deck"""
        self.assertEqual(self.deck.count(), 52)
        self.deck.cards.pop()
        self.assertEqual(self.deck.count(), 51)

    def test_deal_sufficient_cards(self):
        """_deal should deal the number of cards specified if there are enough cards in the deck"""
        cards = self.deck._deal(10)
        self.assertEqual(len(cards), 10)
        self.assertEqual(self.deck.count(), 42)

    def test_deal_insufficient_cards(self):
        """_deal should deal the number of cards left in the deck if there's not enough cards in the deck"""
        cards = self.deck._deal(100)
        self.assertEqual(len(cards), 52)
        self.assertEqual(self.deck.count(), 0)

    def test_deal_no_cards(self):
        """_deal should throw a ValueError if the deck is empty"""
        self.deck._deal(self.deck.count())
        with self.assertRaises(ValueError):
            self.deck._deal(1)

    def test_deal_card(self):
        """deal_cards should deal a single card"""
        card = self.deck.cards[-1]
        dealt_card = self.deck.deal_card()
        self.assertEqual(card, dealt_card)
        self.assertEqual(self.deck.count(), 51)

    def test_deal_hand(self):
        """deal_hand shoudl deal the number of cards passed in"""
        cards = self.deck.deal_hand(20)
        self.assertEqual(len(cards), 20)
        self.assertEqual(self.deck.count(), 32)

    def test_shuffle_full_deck(self):
        """shuffle should shuffle the deck if the deck is full"""
        cards = self.deck.cards[:]
        self.deck.shuffle()
        self.assertNotEqual(cards, self.deck.cards)
        self.assertEqual(self.deck.count(), 52)

    def test_shuffle_not_full_deck(self):
        """shuffle should not shuffle an incomplete deck"""
        self.deck._deal(1)
        with self.assertRaises(ValueError):
            self.deck.shuffle()