class Test_Team(unittest.TestCase):
    def setUp(self) -> None:
        print("Entering team setup")
        self.brandon = Player("Brandon", "Ravens", 8)
        self.nick = Player("Nick", "Ravens", 9)
        self.hunter = Player("Hunter", "Ravens", 10)
        self.teamMates = [self.brandon, self.nick, self.hunter]
        self.owner = Owner("Jason hibbeler", "Ravens")
        self.newTeam = Team(self.teamMates, "Ravens", self.owner)
        self.newTeam.printTeam()

    def tearDown(self) -> None:
        print("TearDown Team")
        self.newTeam = None
        print()

    def test_players(self):
        self.assertRaises(NameError, Team, [], "Blues", self.owner)
        print("Entering test_players in Test_Team")
        self.assertEqual(self.newTeam.teamList[0], self.brandon)
        self.assertEqual(self.newTeam.teamList[1], self.nick)
        self.assertEqual(self.newTeam.teamList[2], self.hunter)
        self.assertEqual(self.newTeam.teamList[0].team, "Ravens")
        self.assertEqual(self.newTeam.teamList[1].team, "Ravens")
        self.assertEqual(self.newTeam.teamList[2].team, "Ravens")
        self.assertEqual(self.newTeam.teamList, self.newTeam.getPlayers())

    def test_getters(self):
        self.assertEqual(self.newTeam.teamList, self.newTeam.getPlayers())
        self.assertEqual(self.newTeam.name, self.newTeam.getName())

    def test_newPlayer(self):
        print("Entering test_newPlayer in Test_Team")
        maxx = Player("Maxx", "Ravens", 98)
        self.newTeam.newPlayer(maxx)
        self.assertEqual(self.newTeam.teamList[3].name, "Maxx")
        self.assertEqual(self.newTeam.teamList[3].team, "Ravens")
        self.newTeam.printTeam()

    def test_firePlayer(self):
        print("Entering test_firePlayer in Test_Team")
        self.assertEqual(self.newTeam.teamList, self.teamMates)
        test_list2 = [self.brandon, self.nick]
        self.newTeam.firePlayer(self.hunter)
        self.assertEqual(self.newTeam.teamList, test_list2)
        diffPlayer = Player("Bernie Sanders", "Bills", 99)
        self.assertRaises(ValueError, self.newTeam.firePlayer, diffPlayer)

    def test_owner(self):
        print("Entering test_owner in Test_Team")
        self.assertEqual(self.newTeam.teamOwner, self.owner)
        self.assertEqual(self.newTeam.teamOwner.name, "Jason hibbeler")
        self.assertEqual(self.newTeam.teamOwner.team, "Ravens")

    def test_newOwner(self):
        print("Entering test_newOwner in Test_Team")
        newOwner = Owner("Tome Hanks", "Ravens")
        newOwnerDiffTeam = Owner("Bill Gates", "Colts")
        self.newTeam.newOwner(newOwner)
        self.assertEqual(self.newTeam.teamOwner, newOwner)
        self.assertRaises(ValueError, self.newTeam.newOwner, newOwnerDiffTeam)

    def test_fireOwner(self):
        print("Entering test_fireOwner in Test_Team")
        self.newTeam.fireOwner()
        self.assertEqual(self.newTeam.teamOwner, None)

    def test_findPlayer(self):
        test_player = Player("Howard", "Bears", 43)
        self.assertEqual(self.newTeam.findPlayer(self.nick), 0)
        self.assertEqual(self.newTeam.findPlayer(test_player), -1)
Пример #2
0
class TeamTest(unittest.TestCase):

    # the testing framework will automatically call for every single test we run
    # in our case, it can also serve as constructor test
    def setUp(self):
        self.public = True
        self.private = False

        self.L1 = Student(1, "L1", self.private)
        self.L2 = Student(2, "L2", self.private)

        self.M11 = Student(11, "M11", self.private)
        self.M12 = Student(12, "M12", self.private)

        # initialize Team Objects Team(name, id, publicity, leader)
        #                                                     v
        #                                        Student(id, username, publicity)
        self.Team1 = Team("Team1", 1, self.public, self.L1)
        self.Team2 = Team("Team2", 2, self.private, self.L2)

    # test all getters
    def test_gets(self):
        self.assertEqual(self.Team1.getName(), "Team1")
        self.assertEqual(self.Team1.getID(), 1)
        self.assertTrue(self.Team1.getPublicity())
        self.assertEqual(self.Team1.getLeader().getID(), 1)
        self.assertEqual(len(self.Team1.getTags()), 0)
        self.assertEqual(len(self.Team1.getMembers()), 1)
        self.assertEqual((self.Team1.getMembers())[0].getID(), 1)

    # test all setters
    def test_sets(self):
        self.Team1.setName("newTeam1")
        self.assertEqual(self.Team1.getName(), "newTeam1")

        self.Team1.setPublicity(self.private)
        self.assertFalse(self.Team1.getPublicity())

    def test_addAndRemoveMembers(self):
        # add two members to Team1
        self.assertTrue(self.Team1.addMember(self.M11))
        self.assertTrue(self.Team1.addMember(self.M12))
        self.assertEqual(len(self.Team1.getMembers()), 3)
        self.assertEqual((self.Team1.getMembers())[0].getID(), 1)
        self.assertEqual((self.Team1.getMembers())[1].getID(), 11)
        self.assertEqual((self.Team1.getMembers())[2].getID(), 12)

        # invalid add
        self.assertFalse(self.Team1.addMember(self.M11))

        # remove one member
        self.assertTrue(self.Team1.removeMember(self.M11))
        self.assertEqual(len(self.Team1.getMembers()), 2)
        self.assertEqual((self.Team1.getMembers())[0].getID(), 1)
        self.assertEqual((self.Team1.getMembers())[1].getID(), 12)

        # remove team leader should fail
        self.assertFalse(self.Team1.removeMember(self.L1))
        # remove a non-existing member should fail
        self.assertFalse(self.Team1.removeMember(self.M11))

        # remove another member
        self.assertTrue(self.Team1.removeMember(self.M12))
        self.assertEqual(len(self.Team1.getMembers()), 1)
        self.assertEqual((self.Team1.getMembers())[0].getID(), 1)

    def test_addAndDeleteTags(self):
        # valid adds
        self.assertTrue(self.Team1.addTag("EDT"))
        self.assertTrue(self.Team1.addTag("Tuesday"))
        self.assertEqual(len(self.Team1.getTags()), 2)

        # invalid adds, duplicates
        self.assertFalse(self.Team1.addTag("EDT"))
        self.assertEqual(len(self.Team1.getTags()), 2)

        self.assertEqual((self.Team1.getTags())[0], "EDT")
        self.assertEqual((self.Team1.getTags())[1], "Tuesday")

        # invalid deletes
        self.assertFalse(self.Team1.deleteTag("PDT"))
        self.assertEqual(len(self.Team1.getTags()), 2)

        # valid deletes
        self.assertTrue(self.Team1.deleteTag("EDT"))
        self.assertEqual(len(self.Team1.getTags()), 1)
        self.assertEqual((self.Team1.getTags())[0], "Tuesday")

        self.assertTrue(self.Team1.deleteTag("Tuesday"))
        self.assertEqual(len(self.Team1.getTags()), 0)

    def test_changeLeader(self):
        # invalid change (not a member in the team)
        self.assertFalse(self.Team1.changeLeader(self.M11))
        self.assertEqual(len(self.Team1.getMembers()), 1)
        self.assertEqual(self.Team1.getLeader().getID(), 1)

        # invalid change (already a leader)
        self.assertFalse(self.Team1.changeLeader(self.L1))
        self.assertEqual(len(self.Team1.getMembers()), 1)
        self.assertEqual(self.Team1.getLeader().getID(), 1)

        # valid change
        self.Team1.addMember(self.M11)
        self.assertEqual(len(self.Team1.getMembers()), 2)
        self.assertTrue(self.Team1.changeLeader(self.M11))
        self.assertEqual(self.Team1.getLeader().getID(), 11)

    def test_dismiss(self):
        self.Team1.dismiss()
        self.assertEqual(len(self.Team1.getMembers()), 0)
        self.assertEqual(len(self.Team1.getTags()), 0)