Die_Game/montecarlo_test.py at main · leandersen/Die_Game · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
import unittest
import numpy as np
import pandas as pd
from montecarlo import montecarlo

card_faces = np.array(["Ace", "King", "Queen", "Jack", 10, 9, 8, 7, 6, 5, 4, 3, 2, 1])
wrong_faces = np.array(["Ace", "Heads", "Tails"])

class TestMC(unittest.TestCase):

    ## Die Class

    def test_01_init_error(self):
        # Faces must be a NumPy array
        self.assertRaises(TypeError, montecarlo.Die, ['Ace', 'King', 'Queen', "Jack"])
        # Faces must be distinct values
        self.assertRaises(ValueError, montecarlo.Die, np.array(['Ace', 'Ace', 'Queen','Jack']))
        # Initialize Die
        cards = montecarlo.Die(card_faces)
        # _die_info is a DataFrame
        self.assertIsInstance(cards._die_info, pd.DataFrame)

    def test_02_change_weight(self):
        # Initialize Die
        cards = montecarlo.Die(card_faces)
        # Face value must be valid
        self.assertRaises(IndexError, cards.change_weight, "Test", 1)
        # Weight must be integer or float
        self.assertRaises(TypeError, cards.change_weight, "Ace", "Test")
        # Weight must change
        cards.change_weight("Ace", 5)
        self.assertEqual(cards._die_info.loc["Ace", "Weight"], 5, "Weight did not change to five.")

    def test_03_roll_die(self):
        # Initialize Die
        cards = montecarlo.Die(card_faces)
        # Must return list
        self.assertIsInstance(cards.roll_die(), list)
        # Must take an Integer (not float)
        self.assertRaises(TypeError, cards.roll_die, 1.35)

    def test_04_show_die(self):
        # Initialize Die
        cards = montecarlo.Die(card_faces)
        # Must return a DataFrame
        self.assertIsInstance(cards.show_die(), pd.DataFrame)

    ## Game Class

    def test_05_init_error(self):
        # Must take a list (not tuple)
        self.assertRaises(TypeError, montecarlo.Game, tuple([1,2]))
        # Faces must be identical
        cards_1 = montecarlo.Die(card_faces)
        cards_2 = montecarlo.Die(wrong_faces)
        self.assertRaises(ValueError, montecarlo.Game, [cards_1, cards_2])

    def test_06_play_game(self):
        # Initialize game
        cards_1 = montecarlo.Die(card_faces)
        cards_2 = montecarlo.Die(card_faces)
        cards_3 = montecarlo.Die(card_faces)
        game = montecarlo.Game([cards_1, cards_2, cards_3])
        game.play_game(5)
        # Must take an Integer (not float)
        self.assertRaises(TypeError, game.play_game, 1.35)
        # Output is DataFrame
        self.assertIsInstance(game._game_results, pd.DataFrame)

    def test_07_show_results(self):
        # Initialize game
        cards_1 = montecarlo.Die(card_faces)
        cards_2 = montecarlo.Die(card_faces)
        cards_3 = montecarlo.Die(card_faces)
        game = montecarlo.Game([cards_1, cards_2, cards_3])
        game.play_game(5)
        # Must be narrow or wide
        self.assertRaises(ValueError, game.show_results, "skinny")
        # Must be DataFrame when narrow
        self.assertIsInstance(game.show_results('narrow'), pd.DataFrame)
        # Must be DataFrame when wide
        self.assertIsInstance(game.show_results('wide'), pd.DataFrame)

    ## Analyzer Class

    def test_08_init_error(self):
        # Must take a game object
        self.assertRaises(ValueError, montecarlo.Analyzer, montecarlo.Die)

    def test_09_jackpot(self):
        # Initialize Analyzer
        cards_1 = montecarlo.Die(np.array(["Heads"]))
        cards_2 = montecarlo.Die(np.array(["Heads"]))
        game = montecarlo.Game([cards_1, cards_2])
        game.play_game(5)
        analyze = montecarlo.Analyzer(game)
        # Must return integer
        self.assertIsInstance(analyze.jackpot(), int)
        # Returns correct number of jackpots
        self.assertEqual(analyze.jackpot(), 5)

    def test_10_face_count(self):
        #Initialize Analyzer
        cards_1 = montecarlo.Die(np.array(["Heads"]))
        cards_2 = montecarlo.Die(np.array(["Heads"]))
        game = montecarlo.Game([cards_1, cards_2])
        game.play_game(5)
        analyze = montecarlo.Analyzer(game)
        # Returns correct count of faces for each roll
        self.assertEqual(analyze.face_count().loc[0,"Heads"], 2)
        # Returns a DataFrame
        self.assertIsInstance(analyze.face_count(), pd.DataFrame)

    def test_11_combo_count(self):
        #Initialize Analyzer
        cards_1 = montecarlo.Die(np.array(["Heads"]))
        cards_2 = montecarlo.Die(np.array(["Heads"]))
        game = montecarlo.Game([cards_1, cards_2])
        game.play_game(5)
        analyze = montecarlo.Analyzer(game)
        # Returns correct number of combos
        self.assertEqual(analyze.combo_count().loc[("Heads", "Heads"),"count"], 5)
        # Returns a DataFrame
        self.assertIsInstance(analyze.combo_count(), pd.DataFrame)

    def test_12_perm_count(self):
        #Initialize Analyzer
        cards_1 = montecarlo.Die(np.array(["Heads"]))
        cards_2 = montecarlo.Die(np.array(["Heads"]))
        game_1 = montecarlo.Game([cards_1, cards_2])
        game_1.play_game(5)
        analyze_1 = montecarlo.Analyzer(game_1)
        # Returns correct number of combos
        self.assertEqual(analyze_1.perm_count().loc[("Heads", "Heads"),"count"], 5)
        # Returns a DataFrame
        self.assertIsInstance(analyze_1.perm_count(), pd.DataFrame)

if __name__ == '__main__':
    unittest.main(verbosity=3)