def inviteAnswerReply(self, answer, members, inviter, invitee):
from player import localPlayer
from team import Team
from player_manager import playerManager
from team_manager import teamManager
from draw_ import draw
if localPlayer.name is invitee.name:
newTeam = Team()
newTeam.create(inviter)
for member in members:
newTeam.add(member)
#更新玩家和team 数据 idea-->定义一个“更新”类，用@classmethod？
invitee.team = newTeam
inviter.team = newTeam
playerManager.add(inviter)
playerManager.add(invitee)
teamManager.add(newTeam)
#画出队伍成员
draw.disDrawTeamMember()
draw.drawTeamMember(newTeam)
elif localPlayer.name is inviter.name:
inviter.team = teamManager.get(inviter)
inviter.team.add(invitee)
#更新玩家和team 数据
playerManager.add(inviter)
teamManager.add(inviter.team)
#画出队伍成员
draw.disDrawTeamMember()
draw.drawTeamMember(inviter.team)
else:# 其他队员
localPlayer.team.add(invitee)
#更新玩家和team 数据
playerManager.add(localPlayer)
teamManager.add(localPlayer.team)
#画出队伍成员
draw.disDrawTeamMember()
draw.drawTeamMember(localPlayer.team)
class TestTeam(TestCase):
""" Unit Tests for the Team Class """
TEST_PLAYERS = {"Forward": [], "Goalie": []}
@patch('builtins.open', mock_open(read_data=""))
def setUp(self):
""" Creates test fixture """
self.logPoint()
json.load = MagicMock(return_value=TestTeam.TEST_PLAYERS)
self.team = Team("testplayers.json")
self.forward = PlayerForward("Sven", "Baertschi", 180.34, 190, 47,
"Oct 5, 1992", "2011", "LW", "L", 8, 5,
40, "forward")
self.forward_id = id(self.forward)
(self.forward).set_id(self.forward_id)
self.goalie = PlayerGoalie("Roberto", "Luongo", 190.5, 215, 1,
"Apr 4, 1979", 1997, 788, 83, 705, 30, 12,
13, "goalie")
self.goalie_id = id(self.goalie)
(self.goalie).set_id(self.goalie_id)
self.undefined_value = None
self.empty_value = ""
def test_team(self):
""" 010A: Valid Construction """
self.assertIsNotNone(self.team, "Team must be defined")
@patch('builtins.open', mock_open(read_data=""))
def test_add(self):
""" 020A: Valid Add Player """
self.assertIsNotNone(self.forward, "Player must be defined")
returned_id = self.team.add(self.forward)
self.assertEqual(returned_id, self.forward_id,
"Player must have id %s" % self.forward_id)
self.assertEqual(len(self.team.get_all_players()), 1,
"Team must have 1 player")
@patch('builtins.open', mock_open(read_data=""))
def test_add_undefined(self):
""" 020B: Invalid Add Player """
undefined_player = None
self.assertRaisesRegex(ValueError, "Player must be defined",
self.team.add, undefined_player)
@patch('builtins.open', mock_open(read_data=""))
def test_add_player_already_exists(self):
""" 020C: Invalid Add Player - Player Already Exists """
self.assertEqual(len(self.team.get_all_players()), 0,
"Team must have no players")
self.team.add(self.forward)
self.assertEqual(len(self.team.get_all_players()), 1,
"Team must have 1 player")
self.team.add(self.forward)
self.assertEqual(len(self.team.get_all_players()), 1,
"Team must still only have 1 player")
@patch('builtins.open', mock_open(read_data=""))
def test_delete(self):
""" 030A: Valid Delete Player """
self.team.add(self.forward)
player_list = self.team.get_all_players()
self.assertEqual(len(player_list), 1, "Team must have 1 player")
self.assertEqual(player_list[0].get_id(), self.forward_id)
self.team.delete(self.forward_id)
self.assertEqual(len(self.team.get_all_players()), 0,
"Team must have no players")
@patch('builtins.open', mock_open(read_data=""))
def test_delete_invalid_player_id(self):
""" 030B: Invalid Delete Player Parameters """
self.assertRaisesRegex(ValueError, "Player ID cannot be undefined",
self.team.delete, self.undefined_value)
self.assertRaisesRegex(ValueError, "Player ID cannot be empty",
self.team.delete, self.empty_value)
@patch('builtins.open', mock_open(read_data=""))
def test_delete_non_existent_player(self):
""" 030C: Invalid Delete Player - Player is Non-Existent """
self.team.add(self.forward)
player_list = self.team.get_all_players()
self.assertEqual(len(player_list), 1, "Team must have 1 player")
self.assertEqual(player_list[0].get_id(), self.forward_id)
self.assertRaisesRegex(ValueError, "Player ID does not exist",
self.team.delete, self.goalie_id)
self.assertEqual(len(self.team.get_all_players()), 1,
"Team must have 1 player")
@patch('builtins.open', mock_open(read_data=""))
def test_get_player(self):
""" 040A: Valid Get Player """
self.team.add(self.forward)
retrieved_player = self.team.get_player(self.forward_id)
self.assertEqual(retrieved_player.get_id(), self.forward_id,
"Player must have player ID %s" % (self.forward_id))
self.assertEqual(retrieved_player.get_zone(), "LW",
"Player must have zone LW")
self.assertEqual(retrieved_player.get_stats(), [8, 5, 40],
"Player must have stats [8, 5, 40]")
@patch('builtins.open', mock_open(read_data=""))
def test_get_player_invalid_player_id(self):
""" 040B: Invalid Get Player Parameters """
self.assertRaisesRegex(ValueError, "Player ID cannot be undefined",
self.team.get_player, self.undefined_value)
self.assertRaisesRegex(ValueError, "Player ID cannot be empty",
self.team.get_player, self.empty_value)
@patch('builtins.open', mock_open(read_data=""))
def test_get_player_non_existent(self):
""" 040C: Invalid Get Player - Player is Non-Existent"""
self.team.add(self.forward)
self.team.add(self.goalie)
self.assertIsNone(self.team.get_player(99),
"No player should exist for 99")
@patch('builtins.open', mock_open(read_data=""))
def test_get_all_players(self):
""" 050A: Valid get_all_players() """
self.team.add(self.forward)
self.team.add(self.goalie)
list_players = self.team.get_all_players()
self.assertEqual(len(list_players), 2)
self.assertEqual(list_players[0].get_fname(), "Sven",
"Player must have first name 'Sven'")
self.assertEqual(list_players[1].get_id(), self.goalie_id,
"Player must have id %s" % self.goalie_id)
@patch('builtins.open', mock_open(read_data=""))
def test_get_all_players_invalid(self):
""" 050B: Invalid get_all_players() """
list_players = self.team.get_all_players()
# Check empty list
self.assertEqual(len(list_players), 0, "Team must have no players")
self.team.add(self.forward)
list_players = self.team.get_all_players()
self.assertIsNotNone(list_players[0], "Player must be defined")
@patch('builtins.open', mock_open(read_data=""))
def test_get_all_by_type(self):
""" 060A: Valid Get all by Type """
self.team.add(self.forward)
self.team.add(self.goalie)
list_players_forward = self.team.get_all_by_type("Forward")
list_players_goalie = self.team.get_all_by_type("Goalie")
self.assertEqual(len(list_players_forward), 1)
self.assertEqual(list_players_forward[0].get_type(), "Forward",
"Player must have Player Type Forward")
self.assertEqual(len(list_players_goalie), 1)
self.assertEqual(list_players_goalie[0].get_type(), "Goalie",
"Player must have Player Type Goalie")
def test_get_all_by_type_invalid_player_type(self):
""" 060B: Invalid Get all by Type Parameters """
self.assertRaisesRegex(ValueError, "Player Type cannot be undefined",
self.team.get_all_by_type, self.undefined_value)
self.assertRaisesRegex(ValueError, "Player Type cannot be empty",
self.team.get_all_by_type, self.empty_value)
self.assertRaisesRegex(ValueError,
"Player Type must be Forward or Goalie",
self.team.get_all_by_type, "Defense")
@patch('builtins.open', mock_open(read_data=""))
def test_update(self):
""" 070A: Valid Update """
self.team.add(self.forward)
self.team.add(self.goalie)
new_forward = PlayerForward("Yann", "Sauve", 190.5, 207.24, 47,
"Feb 18, 1990", "2008", "RW", "L", 12, 8,
43, "forward")
new_forward.set_id(self.forward_id)
self.team.update(new_forward)
self.assertEqual(
self.team.get_player(self.forward_id).get_full_name(),
"Yann Sauve")
def tearDown(self):
self.logPoint()
def logPoint(self):
currentTest = self.id().split('.')[-1]
callingFunction = inspect.stack()[1][3]
print('in %s - %s()' % (currentTest, callingFunction))
class TestTeam(unittest.TestCase):
def setUp(self):
self.team = Team(2)
def test_add(self):
self.team.add("Player")
self.assertIn("Player", self.team)
def test_multiple_add(self):
self.team.add("Player1", "Player2")
self.assertTrue("Player1" in self.team and "Player2" in self.team,
msg=str(self.team.get_players()))
def test_duplicate_add(self):
self.team.add("Player")
self.assertRaises(AssertionError, self.team.add, "Player")
def test_team_max(self):
self.team.add("1")
self.team.add("2")
self.assertRaises(AssertionError, self.team.add, "3")
def test_remove(self):
self.team.add("Player")
self.team.remove("Player")
self.assertNotIn("Player", self.team)
def test_remove_nonexisting(self):
self.assertRaises(ValueError, self.team.remove, "Player")
def test_get_players(self):
self.team.add("Player")
something = self.team.get_players()
self.assertEqual(something, self.team.players)
def test_iterable(self):
y = iter(self.team)
players = iter(self.team.players)
compared_players = (x1 == x2 for x1, x2 in zip(y, players))
self.assertTrue(all(compared_players))
def test_iterable_realcase(self):
self.team.add("Player1")
self.team.add("Player2")
found = False
for player in self.team:
if player == "Player2":
found = True
self.assertTrue(found)
def test_clear(self):
self.team.add("Player1")
self.team.add("Player2")
self.team.clear()
self.team == None
def test_bool(self):
self.team.add("Player1")
self.team.add("Player2")
self.assertTrue(self.team)
from user import User
from team import Team
if __name__ == '__main__':
# create and print a default Team
team = Team()
print(team)
# add users
team.add(User("Cam"))
team.add(User("Pam"))
# make one user different
team.get("Pam").score += 1
print(team)
# test get with existing user
print(team.get("Pam"))
# test get with missing user
print(team.get("Sam"))
# test get_leader
print(team.get_leader())
432, 40, 20, 20, 20, "goalie")
team = Team("./players.json")
#team.add(player1)
#team.add(player2)
#team.add(player3)
#player3_id = player3.get_id()
#print(id((team.get_all_players())[0]))
# team.delete(id(player2))
#player_list = team.get_all_players()
#player1 = player_list[0]
#print(player1.to_dict())
#print(json.dumps((team.get_all_players())["2380120105032"], indent=4))
team.add(player1)
print(team)
#team.delete(2101412049304)
#print(repr(team))
#forwards = team.get_all_by_type("Forward")
#print(forwards)
from team import Team
from player_forward import PlayerForward
from player_goalie import PlayerGoalie
team_a = Team()
forward = PlayerForward(47, "Sven", "Baertschi", 180.34, 190, 47,
"Oct 5, 1992", "2011", "LW", "L", 8, 5, 40)
goalie = PlayerGoalie(1, "Roberto", "Luongo", 190.5, 215, 1, "Apr 4, 1979",
1997, 788, 83, 705, 30, 12, 13)
forward_update = PlayerForward(47, "QUACK", "Baertschi", 180.34, 190, 47,
"Oct 5, 1992", "2011", "LW", "L", 8, 5, 40)
team_a.add(forward)
team_a.add(goalie)
team_a.update(forward_update)
list_players = team_a.get_all_players()
player_1 = list_players[0].get_fname()
player_2 = list_players[1].get_fname()
print(player_1)
print(player_2)
