def setUp(self):
     self.logPoint()
     self.test_player_forward = PlayerForward("Sven", "Baertschi", 180.34,
                                              190, 47, "Oct 5, 1992",
                                              "2011", "LW", "L", 8, 5, 40,
                                              "Forward")
     self.none_value = None
     self.empty_value = ""
Пример #2
0
    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")
Пример #3
0
 def setUp(self):
     self.logPoint()
     self.team = Team()
     self.forward = PlayerForward(47, "Sven", "Baertschi", 180.34, 190, 47, "Oct 5, 1992", "2011", "LW", "L", 8, 5, 40)
     self.goalie = PlayerGoalie(1, "Roberto", "Luongo", 190.5, 215, 1, "Apr 4, 1979", 1997, 788, 83, 705, 30, 12, 13)
     self.undefined_value = None
     self.empty_value = ""
Пример #4
0
    def _read_player_from_file(self):
        """ Private method to load the JSON player records from the file at _filepath into the list of players """

        with open(self._filepath) as player_file:
            data = player_file.read()

            if (data== None) or (data == ""):
                return

            players_obj = json.loads(data)

            for key, value in players_obj.items():
                if key.lower() == "forward":
                    for i in value:
                        player = PlayerForward(i['fname'], i['lname'], i['height'], i['weight'], i['jersey_num'], i['date_birth'],
                                               i['year_joined'], i['zone'], i['shooting_hand'], i['goals'], i['assists'], i['total_shots'], i['player_type'])
                        player.set_id(i['id'])
                        self._team_players.append(player)
                elif key.lower() == "goalie":
                    for i in value:
                        player = PlayerGoalie(i['fname'], i['lname'], i['height'], i['weight'], i['jersey_num'], i['date_birth'], i['year_joined'],
                                              i['shots_against'], i['goals_against'], i['goals_saved'], i['games_played'], i['games_won'], i['games_lost'], i['player_type'])
                        player.set_id(i['id'])
                        self._team_players.append(player)
                else:
                    continue

        return
Пример #5
0
def update_player(player_id):
    """ Updates player's attributes """
    content = request.json

    try:
        player_type = content["player_type"].lower()

        if player_type == PLAYER_TYPE_FORWARD:
            player = PlayerForward(content["fname"], content["lname"], content["height"], content["weight"], content["jersey_num"], content["date_birth"], content["year_joined"], content["zone"], content["shooting_hand"], content["goals"], content["assists"], content["total_shots"], content["player_type"])
            player.set_id(player_id)
            team.update(player)
            response = app.response_class(
                status=200
            )
        elif player_type == PLAYER_TYPE_GOALIE:
            player = PlayerGoalie(content["fname"], content["lname"], content["height"], content["weight"], content["jersey_num"], content["date_birth"], content["year_joined"], content["shots_against"], content["goals_against"], content["goals_saved"], content["games_played"], content["games_won"], content["games_lost"], content["player_type"])
            player.set_id(player_id)
            team.update(player)
            response = app.response_class(
                status=200
            )
        else:
            raise Exception

    except ValueError as e:
        response = app.response_class(
            status=404,
            response=str(e)
        )

    return response
class TestPlayerForward(TestCase):
    """ Unit tests for PlayerForward clas """
    def setUp(self):
        self.logPoint()
        self.test_player_forward = PlayerForward(47, "Sven", "Baertschi",
                                                 180.34, 190, 47,
                                                 "Oct 5, 1992", "2011", "LW",
                                                 "L", 8, 5, 40)

    def test_player_forward_valid(self):
        """ 010A: Valid values for constructor """
        self.logPoint()
        self.assertIsNotNone(self.test_player_forward)

    def test_get_zone(self):
        """ 020A: Valid return for get_zone() """
        self.logPoint()
        self.assertEqual(self.test_player_forward.get_zone(), "LW")

    def test_get_shooting_hand(self):
        """ 030A: Valid return of get_shooting_hand() """
        self.logPoint()
        self.assertEqual(self.test_player_forward.get_shooting_hand(), "L")

    def test_get_goals(self):
        """ 040A: Valid return of get_goals() """
        self.logPoint()
        self.assertEqual(self.test_player_forward.get_goals(), 8)

    def test_get_assists(self):
        """ 050A: Valid return of get_assists() """
        self.logPoint()
        self.assertEqual(self.test_player_forward.get_assists(), 5)

    def test_get_total_shots(self):
        """ 060A: Valid return of get_total_shots() """
        self.logPoint()
        self.assertEqual(self.test_player_forward.get_total_shots(), 40)

    def test_get_stats(self):
        """ 070A: Valid return of get_stats() """
        self.logPoint()
        self.assertEqual(self.test_player_forward.get_stats(), [8, 5, 40])

    def test_get_type(self):
        """ 080A: Valid return of get_type() """
        self.logPoint()
        self.assertEqual(self.test_player_forward.get_type(), "Forward")

    def tearDown(self):
        self.logPoint()

    def logPoint(self):
        currentTest = self.id().split('.')[-1]
        callingFunction = inspect.stack()[1][3]
        print('in %s - %s()' % (currentTest, callingFunction))
Пример #7
0
def add_player():
    """ Adds a player to the team """
    content = request.json

    try:
        player_type = content["player_type"].lower()

        if player_type == PLAYER_TYPE_FORWARD:
            player = PlayerForward(content["fname"], content["lname"], content["height"], content["weight"], content["jersey_num"], content["date_birth"], content["year_joined"], content["zone"], content["shooting_hand"], content["goals"], content["assists"], content["total_shots"], content["player_type"])

            team.add(player)

            id = str(player.get_id())

            response = app.response_class(
                status=200,
                response=id
            )
        elif player_type == PLAYER_TYPE_GOALIE:
            player = PlayerGoalie(content["fname"], content["lname"], content["height"], content["weight"], content["jersey_num"], content["date_birth"], content["year_joined"], content["shots_against"], content["goals_against"], content["goals_saved"], content["games_played"], content["games_won"], content["games_lost"], content["player_type"])

            team.add(player)

            id = str(player.get_id())

            response = app.response_class(
                status=200,
                response=id
            )
        else:
            raise Exception
    except:
        response = app.response_class(
            response="Player is invalid",
            status=400
        )

    return response
Пример #8
0
    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 setUp(self):
     self.logPoint()
     self.test_player_forward = PlayerForward(47, "Sven", "Baertschi",
                                              180.34, 190, 47,
                                              "Oct 5, 1992", "2011", "LW",
                                              "L", 8, 5, 40)
Пример #10
0
from player_forward import PlayerForward
from player_goalie import PlayerGoalie
from team import Team
import json
import os

player1 = PlayerForward("Sven", "Baertschi", 180.34, 190, 47, "Oct 5, 1992",
                        "2011", "LW", "L", 8, 5, 40, "forward")
player2 = PlayerForward("John", "Doe", 123, 23, 3, "Sept 2, 2534", "1234",
                        "WN", "R", 3, 5, 65, "Forward")
player3 = PlayerGoalie("Bob", "Smith", 321, 100, 4, "Jan 1, 1990", "2000", 123,
                       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)
Пример #11
0
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)
class TestPlayerForward(TestCase):
    """ Unit tests for PlayerForward class """
    def setUp(self):
        self.logPoint()
        self.test_player_forward = PlayerForward("Sven", "Baertschi", 180.34,
                                                 190, 47, "Oct 5, 1992",
                                                 "2011", "LW", "L", 8, 5, 40,
                                                 "Forward")
        self.none_value = None
        self.empty_value = ""

    def test_player_forward_valid(self):
        """ 010A: Valid values for constructor """
        self.assertIsNotNone(self.test_player_forward)

    def test_player_forward_invalid_undefined(self):
        """ 010B: Invalid values for constructor """
        self.assertRaisesRegex(ValueError, "fname cannot be undefined",
                               PlayerForward, self.none_value, "Baertschi",
                               180.34, 190, 47, "Oct 5, 1992", "2011", "LW",
                               "L", 8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "lname cannot be undefined",
                               PlayerForward, "Sven", self.none_value, 180.34,
                               190, 47, "Oct 5, 1992", "2011", "LW", "L", 8, 5,
                               40, "Forward")
        self.assertRaisesRegex(ValueError, "height cannot be undefined",
                               PlayerForward, "Sven", "Baertschi",
                               self.none_value, 190, 47, "Oct 5, 1992", "2011",
                               "LW", "L", 8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "weight cannot be undefined",
                               PlayerForward, "Sven", "Baertschi", 180.34,
                               self.none_value, 47, "Oct 5, 1992", "2011",
                               "LW", "L", 8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "jersey_num cannot be undefined",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               self.none_value, "Oct 5, 1992", "2011", "LW",
                               "L", 8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "date_birth cannot be undefined",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, self.none_value, "2011", "LW", "L", 8, 5,
                               40, "Forward")
        self.assertRaisesRegex(ValueError, "year_joined cannot be undefined",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", self.none_value, "LW", "L",
                               8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "zone cannot be undefined",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", self.none_value, "L",
                               8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "shooting_hand cannot be undefined",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", "LW",
                               self.none_value, 8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "goals cannot be undefined",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", "LW", "L",
                               self.none_value, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "assists cannot be undefined",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", "LW", "L", 8,
                               self.none_value, 40, "Forward")
        self.assertRaisesRegex(ValueError, "total_shots cannot be undefined",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", "LW", "L", 8, 5,
                               self.none_value, "Forward")
        self.assertRaisesRegex(ValueError, "player_type cannot be undefined",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", "LW", "L", 8, 5, 40,
                               self.none_value)

    def test_player_forward_invalid_empty(self):
        """ 010C: Empty values for constructor """
        self.assertRaisesRegex(ValueError, "fname cannot be empty",
                               PlayerForward, self.empty_value, "Baertschi",
                               180.34, 190, 47, "Oct 5, 1992", "2011", "LW",
                               "L", 8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "lname cannot be empty",
                               PlayerForward, "Sven", self.empty_value, 180.34,
                               190, 47, "Oct 5, 1992", "2011", "LW", "L", 8, 5,
                               40, "Forward")
        self.assertRaisesRegex(ValueError, "height cannot be empty",
                               PlayerForward, "Sven", "Baertschi",
                               self.empty_value, 190, 47, "Oct 5, 1992",
                               "2011", "LW", "L", 8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "weight cannot be empty",
                               PlayerForward, "Sven", "Baertschi", 180.34,
                               self.empty_value, 47, "Oct 5, 1992", "2011",
                               "LW", "L", 8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "jersey_num cannot be empty",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               self.empty_value, "Oct 5, 1992", "2011", "LW",
                               "L", 8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "date_birth cannot be empty",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, self.empty_value, "2011", "LW", "L", 8, 5,
                               40, "Forward")
        self.assertRaisesRegex(ValueError, "year_joined cannot be empty",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", self.empty_value, "LW", "L",
                               8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "zone cannot be empty",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", self.empty_value,
                               "L", 8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "shooting_hand cannot be empty",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", "LW",
                               self.empty_value, 8, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "goals cannot be empty",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", "LW", "L",
                               self.empty_value, 5, 40, "Forward")
        self.assertRaisesRegex(ValueError, "assists cannot be empty",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", "LW", "L", 8,
                               self.empty_value, 40, "Forward")
        self.assertRaisesRegex(ValueError, "total_shots cannot be empty",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", "LW", "L", 8, 5,
                               self.empty_value, "Forward")
        self.assertRaisesRegex(ValueError, "player_type cannot be empty",
                               PlayerForward, "Sven", "Baertschi", 180.34, 190,
                               47, "Oct 5, 1992", "2011", "LW", "L", 8, 5, 40,
                               self.empty_value)

    def test_get_zone(self):
        """ 020A: Valid return for get_zone() """
        self.assertEqual(self.test_player_forward.get_zone(), "LW")

    def test_get_shooting_hand(self):
        """ 030A: Valid return of get_shooting_hand() """
        self.assertEqual(self.test_player_forward.get_shooting_hand(), "L")

    def test_get_goals(self):
        """ 040A: Valid return of get_goals() """
        self.assertEqual(self.test_player_forward.get_goals(), 8)

    def test_get_assists(self):
        """ 050A: Valid return of get_assists() """
        self.assertEqual(self.test_player_forward.get_assists(), 5)

    def test_get_total_shots(self):
        """ 060A: Valid return of get_total_shots() """
        self.assertEqual(self.test_player_forward.get_total_shots(), 40)

    def test_get_stats(self):
        """ 070A: Valid return of get_stats() """
        self.assertEqual(self.test_player_forward.get_stats(), [8, 5, 40])

    def test_get_type(self):
        """ 080A: Valid return of get_type() """
        self.assertEqual(self.test_player_forward.get_type(), "Forward")

    def test_to_dict_valid(self):
        """ 090A: Valid to_dict() """
        test_dict = self.test_player_forward.to_dict()

        self.assertEquals(test_dict["fname"], "Sven", "fname must be Sven")
        self.assertEquals(test_dict["lname"], "Baertschi",
                          "lname must be Baertschi")
        self.assertEquals(test_dict["height"], 180.34, "height must be 180.34")
        self.assertEquals(test_dict["weight"], 190, "weight must be 190")
        self.assertEquals(test_dict["jersey_num"], 47, "jersey_num must be 47")
        self.assertEquals(test_dict["date_birth"], "Oct 5, 1992",
                          "date_birth must be Oct 5, 1992")
        self.assertEquals(test_dict["year_joined"], "2011",
                          "year_joined must be 2011")
        self.assertEquals(test_dict["zone"], "LW", "zone must be LW")
        self.assertEquals(test_dict["shooting_hand"], "L",
                          "shooting_hand must be L")
        self.assertEquals(test_dict["goals"], 8, "goals must be 8")
        self.assertEquals(test_dict["assists"], 5, "assists must be 5")
        self.assertEquals(test_dict["total_shots"], 40,
                          "total_shots must be 40")
        self.assertEquals(test_dict["player_type"], "Forward",
                          "player_type must be Forward")

    def tearDown(self):
        self.logPoint()

    def logPoint(self):
        currentTest = self.id().split('.')[-1]
        callingFunction = inspect.stack()[1][3]
        print('in %s - %s()' % (currentTest, callingFunction))