def test_delete_guest(self):
signed_user_controller = SignedUserController()
g1 = Guest("0.0.0.1", 23)
g2 = Guest("0.0.0.2", 46)
signed_user_controller.add_user(g1)
signed_user_controller.add_user(g2)
signed_user_controller.delete_guest(g1.user_ip)
""" Cannot be deleted """
signed_user_controller.delete_guest("0.020.1")
self.assertEqual(1, signed_user_controller.get_guests().__len__())
self.assertIsNone(signed_user_controller.get_guests().get("0.0.0.1"))
def test_number_of_admins(self):
signed_user_controller = SignedUserController()
d1 = datetime.datetime(2020, 4, 23)
d2 = datetime.datetime(2020, 4, 23)
self.assertEqual(0, signed_user_controller.number_of_admins())
signed_user_controller.add_system_admin("name_u1", "1234", "ro", d1,
"0.0.0.5")
signed_user_controller.add_system_admin("name_u21", "1234", "rso", d2,
"0.0.0.2")
signed_user_controller.add_fan_to_data("name_u2221", "12334", "rowe",
d2, "0.0.0.1")
self.assertEqual(2, signed_user_controller.number_of_admins())
def test_show_all_users(self):
signed_user_controller = SignedUserController()
signed_user_controller.add_guest("0.0.0.1")
signed_user_controller.add_guest("0.0.0.3")
signed_user_controller.add_guest("0.0.0.3")
d1 = datetime.datetime(2020, 4, 23)
signed_user_controller.add_signed_user("name_u1", "1234", "ro", d1,
"0.0.0.5")
l1, l2 = signed_user_controller.show_all_users()
self.assertEqual(3, l1.__len__() + l2.__len__())
def test_add_search(self):
signed_user_controller = SignedUserController()
d1 = datetime.datetime(2020, 4, 23)
s = SignedUser("name_u1", "1234", "ro", d1, "0.0.0.5", 23)
signed_user_controller.add_user(s)
signed_user_controller.add_search(s.user_name, "first massage")
signed_user_controller.add_search(s.user_name, "second massage")
self.assertIsNotNone(signed_user_controller)
def test_edit_personal_name(self):
signed_user_controller = SignedUserController()
d1 = datetime.datetime(2020, 4, 23)
signed_user_controller.add_signed_user("name_u1", "1234", "ro", d1,
"0.0.0.5")
self.assertTrue(
signed_user_controller.edit_personal_name("name_u1", "moshe"))
self.assertNotEqual("ro",
signed_user_controller.get_user("name_u1").name)
self.assertEqual("moshe",
signed_user_controller.get_user("name_u1").name)
self.assertFalse(
signed_user_controller.edit_personal_name("name21", "moshe"))
def setUp(self):
# Preparation
self.team_db = MongoTeamDB()
self.user_db = MongoUserDB()
self.team_control = TeamManagementController(self.team_db,
self.user_db)
self.user_controller = SignedUserController(self.user_db)
self.user_controller.add_team_owner('user_nam2', 'password', 'NameB',
date.datetime(1993, 1, 12))
self.owner = self.user_controller.get_user_by_name('user_nam2')
self.user_controller.add_team_owner('user_nam3', 'password', 'NameC',
date.datetime(1993, 1, 12))
self.add_owner = self.user_controller.get_user_by_name('user_nam3')
self.user_controller.add_team_owner('owner_with_team', 'password',
'owner', date.datetime(1993, 1, 1))
self.owner_with_team = self.user_controller.get_user_by_name(
'owner_with_team')
self.user_controller.add_team_manager('user_nam1', 'password', 'nameA',
date.datetime(1993, 1, 1))
self.manager = self.user_controller.get_user_by_name('user_nam1')
self.user_controller.add_team_manager('manager_with_team', 'password',
'manager',
date.datetime(1993, 1, 1))
self.manager_with_team = self.user_controller.get_user_by_name(
'manager_with_team')
self.user_controller.add_player('user_nam4', 'password', 'NameD',
date.datetime(1993, 1, 12))
self.p1 = self.user_controller.get_user_by_name('user_nam4')
self.user_controller.add_player('user_nam5', 'password', 'NameE',
date.datetime(1993, 1, 12))
self.p2 = self.user_controller.get_user_by_name('user_nam5')
self.team_control.open_new_team("Barca", self.owner.user_id)
self.team_control.open_new_team("ajax", self.owner_with_team.user_id)
self.team_control.add_manager_to_team('ajax',
self.manager_with_team.user_id)
def test_add_guest(self):
signed_user_controller = SignedUserController()
signed_user_controller.add_guest("0.0.0.1")
signed_user_controller.add_guest("0.0.0.2")
self.assertEqual(
1,
signed_user_controller.get_guests().get("0.0.0.1").user_id)
self.assertEqual(
2,
signed_user_controller.get_guests().get("0.0.0.2").user_id)
self.assertIsNone(signed_user_controller.get_guests().get("0.0.02"))
def test_edit_personal_birth_date(self):
signed_user_controller = SignedUserController()
d1 = datetime.datetime(2020, 4, 23)
d2 = datetime.datetime(1998, 4, 23)
signed_user_controller.add_signed_user("name_u1", "1234", "ro", d1,
"0.0.0.5")
self.assertTrue(
signed_user_controller.edit_personal_birth_date("name_u1", d2))
self.assertNotEqual(
d1,
signed_user_controller.get_user("name_u1").birth_date)
self.assertEqual(d2,
signed_user_controller.get_user("name_u1").birth_date)
self.assertFalse(
signed_user_controller.edit_personal_birth_date("name21", d1))
def test_add_fan_to_data(self):
signed_user_controller = SignedUserController()
d1 = datetime.datetime(2020, 4, 23)
signed_user_controller.add_fan_to_data("name_u1", "1234", "ro", d1,
"0.0.0.5")
self.assertTrue(signed_user_controller.get_user("name_u1"))
self.assertTrue(
type(signed_user_controller.get_user("name_u1")) is Fan)
def test_confirm_user(self):
signed_user_controller = SignedUserController()
d1 = datetime.datetime(2020, 4, 23)
signed_user_controller.add_system_admin("name_u1", "1234", "ro", d1,
"0.0.0.5")
self.assertEqual(
"SystemAdmin",
signed_user_controller.confirm_user("name_u1", "1234"))
self.assertFalse(
signed_user_controller.confirm_user("name_u1", "12345"))
self.assertFalse(signed_user_controller.confirm_user(
"name_u2", "1234"))
def __init__(self, admin_user_name, admin_password, admin_name,
admin_birth_date, admin_ip):
self.complaint_db = ComplaintDB()
self.game_db = GameDB()
self.league_db = LeagueDB()
self.season_DB = SeasonDB()
self.team_db = TeamDB()
self.user_db = UserDB()
self.policy_db = PolicyDB()
self.union_organization = UnionOrganization()
self.complaint_controller = ComplaintController(self.complaint_db)
self.league_controller = LeagueController(self.league_db,
self.season_DB, PolicyDB)
self.match_controller = MatchController(self.game_db)
self.user_controller = SignedUserController(self.user_db)
self.team_controller = TeamManagementController(self.team_db)
self.union_controller = UnionController(self.union_organization)
self.user_controller.add_system_admin(admin_user_name, admin_password,
admin_name, admin_birth_date,
admin_ip)
def test_add_referee_to_data(self):
signed_user_controller = SignedUserController()
d1 = datetime.datetime(2020, 4, 23)
signed_user_controller.add_referee_to_data(
RefereeQualificationEnum.MAIN, "name_u1", "1234", "ro", d1,
"0.0.0.5")
self.assertTrue(signed_user_controller.get_user("name_u1"))
self.assertTrue(
type(signed_user_controller.get_user("name_u1")) is Referee)
def test_add_system_admin(self):
"""
test if the admin in the DB
If we ran all test its check that ID of the guest is not getting up when we got same guest
@return:
"""
signed_user_controller = SignedUserController()
signed_user_controller.add_guest("0.0.0.1")
d = datetime.datetime(2020, 4, 23)
signed_user_controller.add_system_admin("name_u0", "1234", "ro", d,
"0.0.0.5")
self.assertIsNotNone(
signed_user_controller.get_signed_users().get("name_u0"))
def test_edit_personal_password(self):
signed_user_controller = SignedUserController()
d1 = datetime.datetime(2020, 4, 23)
old_password = "******"
new_password = "******"
signed_user_controller.add_signed_user("name_u1", old_password, "ro",
d1, "0.0.0.5")
self.assertTrue(
signed_user_controller.edit_personal_password(
"name_u1", old_password, new_password))
self.assertNotEqual(
str(hashlib.sha256(old_password.encode()).hexdigest()),
signed_user_controller.get_user("name_u1").password)
self.assertEqual(
str(hashlib.sha256(new_password.encode()).hexdigest()),
signed_user_controller.get_user("name_u1").password)
self.assertFalse(
signed_user_controller.edit_personal_password(
"name1", new_password, old_password))
class AcceptanceTestsSignedUser(TestCase):
# Preparation
user_db = MongoUserDB()
controller = SignedUserController(user_db)
# UC 4.1, UC 5.1, UC 10.1 acceptance tests
# Personal details update received from user GUI
def test_update_personal_info(self):
user_name = 'userName'
password = '******'
self.controller.add_fan(user_name, password, 'name',
date.datetime(2000, 1, 1))
user = self.controller.get_user_by_name(user_name)
# valid details
valid_name = 'Shahar'
valid_birth_date = date.datetime(1993, 1, 1)
# Invalid details
invalid_name = '123'
# --- Testing valid input data ---
# GUI calls to this method in service layer
self.controller.edit_personal_data(user.user_id, user_name, password,
valid_name, valid_birth_date)
self.assertEqual(
self.controller.get_user_by_name(user_name).name, valid_name)
self.assertEqual(
self.controller.get_user_by_name(user_name).birth_date,
valid_birth_date)
# --- Testing invalid input data ---
self.assertRaises(ValueError, self.controller.edit_personal_data,
user.user_id, user_name, password, invalid_name,
valid_birth_date)
self.controller.delete_signed_user(user.user_id)
from Enums.RefereeQualificationEnum import RefereeQualificationEnum
from Enums.EventTypeEnum import EventTypeEnum
import datetime as date
import csv
""" This class is the controller that connects the server to the Domain """
users_db = MongoUserDB()
team_db = MongoTeamDB()
policy_db = MongoPolicyDB()
league_db = MongoLeagueDB()
season_db = MongoSeasonDB()
game_db = MongoGameDB()
game_event_db = MongoGameEventDB()
league_controller = LeagueController(league_db, season_db, users_db, policy_db)
signed_user_controller = SignedUserController(users_db)
notification_controller = NotificationController(users_db, game_db)
team_management_controller = TeamManagementController(team_db, users_db)
match_controller = MatchController(game_db, users_db, game_event_db, team_db)
if not signed_user_controller.confirm_user('dor', '1234'):
signed_user_controller.add_system_admin('dor', '1234', 'dor',
date.datetime(1994, 1, 20))
try:
signed_user_controller.add_team_owner('shahar', '1234', 'shahar',
date.datetime(1993, 1, 1))
signed_user_controller.add_referee(RefereeQualificationEnum.MAIN, 'oscar',
'1234', 'oscar',
date.datetime(1994, 11, 9))
main_referee = signed_user_controller.get_user_by_name('oscar')
owner = signed_user_controller.get_user_by_name('shahar')
from datetime import datetime from Domain.PointsCalculationPolicy import PointsCalculationPolicy from Domain.GameSchedulePolicy import GameSchedulePolicy from Domain.TeamBudgetPolicy import TeamBudgetPolicy user_db = MongoUserDB() team_db = MongoTeamDB() league_db = MongoLeagueDB() policy_db = MongoPolicyDB() season_db = MongoSeasonDB() game_db = MongoGameDB() game_event_db = MongoGameEventDB() match_cont = MatchController(game_db, user_db, game_event_db, team_db) team_cont = TeamManagementController(team_db, user_db) user_con = SignedUserController(user_db) policy = PointsCalculationPolicy(2, 12, 2, 13) policy_db.add_point_policy(policy) # game = game_db.get(1) # game.remove_event(1) # game.remove_event(2) # game.remove_event(3) # game.remove_event(6) # game.remove_event(21) # game.remove_event(22) # game.remove_event(14) # game.remove_event(16) # game.remove_event(17) # game.remove_event(18)
def test_add_user(self):
signed_user_controller = SignedUserController()
d1 = datetime.datetime(2020, 4, 23)
s_u = SignedUser("name_u1", "1234", "ro", d1, "0.0.0.5", 23)
g = Guest("0.0.0.1", 23)
signed_user_controller.add_user(s_u)
signed_user_controller.add_user(g)
self.assertEqual(2, (signed_user_controller.get_guests().__len__()) +
(signed_user_controller.get_signed_users().__len__()))
self.assertIsNotNone(
signed_user_controller.get_signed_users().get("name_u1"))
self.assertIsNotNone(
signed_user_controller.get_guests().get("0.0.0.1"))
self.assertIsNone(
signed_user_controller.get_signed_users().get("0.0.0.1"))
def test_delete_signed_user(self):
signed_user_controller = SignedUserController()
d1 = datetime.datetime(2020, 4, 23)
d2 = datetime.datetime(1998, 4, 23)
signed_user_controller.add_signed_user("name_u1", "1234", "ro", d1,
"0.0.0.5")
signed_user_controller.add_signed_user("name_u2", "1234", "ro", d2,
"0.0.0.6")
signed_user_controller.delete_signed_user("name_u1")
signed_user_controller.delete_signed_user("name_u12")
self.assertEqual(1,
signed_user_controller.get_signed_users().__len__())
self.assertIsNone(
signed_user_controller.get_signed_users().get("name_u1"))
class AcceptanceTestsUnionRepresentor(TestCase):
league_db = MongoLeagueDB()
season_db = MongoSeasonDB()
user_db = MongoUserDB()
team_db = MongoTeamDB()
policy_db = MongoPolicyDB()
league_controller = LeagueController(league_db, season_db, user_db,
policy_db)
team_controller = TeamManagementController(team_db, user_db)
user_controller = SignedUserController(user_db)
pcp = {'win_points': 3, 'tie_points': 0, 'lose_points': -3}
gsp = {
'team_games_num': 2,
'games_per_week': 4,
'chosen_days': ['S', 'M'],
'games_stadium_assigning': GameAssigningPoliciesEnum.EQUAL_HOME_AWAY
}
tbp = {'min_amount': 50000}
def setUp(self):
self.user_controller.add_team_owner('rm_owner', '1234', 'owner',
datetime.now())
self.rm_owner = self.user_controller.get_user_by_name('rm_owner')
self.user_controller.add_team_owner('barca_owner', '1234', 'owner',
datetime.now())
self.barca_owner = self.user_controller.get_user_by_name('barca_owner')
self.user_controller.add_team_owner('lp_owner', '1234', 'owner',
datetime.now())
self.lp_owner = self.user_controller.get_user_by_name('lp_owner')
self.user_controller.add_team_owner('manch_owner', '1234', 'owner',
datetime.now())
self.manch_owner = self.user_controller.get_user_by_name('manch_owner')
self.team_controller.open_new_team('Real Madrid',
self.rm_owner.user_id)
self.team_controller.open_new_team('Barcelona',
self.barca_owner.user_id)
self.team_controller.open_new_team('Liverpool', self.lp_owner.user_id)
self.team_controller.open_new_team('Manchester',
self.manch_owner.user_id)
self.league_controller.create_new_season(2020)
self.season = self.league_controller.get_season(2020)
self.league_controller.create_points_policy(3, 0, -3)
self.points_policy = self.league_controller.get_all_points_policies(
)[0]
self.league_controller.create_game_schedule_policy(
2, 4, GameAssigningPoliciesEnum.EQUAL_HOME_AWAY)
self.schedule_policy = self.league_controller.get_all_schedule_policies(
)[0]
self.league_controller.create_team_budget_policy(50000)
self.budget_policy = self.league_controller.get_all_budget_policies(
)[0]
self.league_controller.create_new_league(
'Euro', 2020, self.points_policy.policy_id,
self.schedule_policy.policy_id, self.budget_policy.policy_id)
self.league = self.league_controller.get_league(
self.league_db.get_id_counter() - 1)
def tearDown(self):
self.league_db.reset_db()
self.league_controller.delete_points_calculation_policy(
self.points_policy.policy_id)
self.league_controller.delete_schedule_calculation_policy(
self.schedule_policy.policy_id)
self.league_controller.delete_budget_calculation_policy(
self.budget_policy.policy_id)
self.season_db.reset_db()
self.team_db.reset_db()
self.user_db.reset_db()
# U.C 9.1, 9.5
def test_create_new_league(self):
self.assertIsInstance(self.league, League)
self.league.add_teams(
['Real Madrid', 'Barcelona', 'Liverpool', 'Manchester'])
# wrong values
self.assertRaises(ValueError, self.league_controller.create_new_league,
'Euro', 2021, self.points_policy.policy_id + 1,
self.schedule_policy.policy_id,
self.budget_policy.policy_id)
# U.C 9.2, 9.4, 9.5
def test_create_new_season(self):
self.assertIsInstance(self.season, Season)
self.assertIn(self.league.league_id,
self.league_controller.get_season(2020).leagues)
# wrong values
self.assertRaises(ValueError, self.league_controller.create_new_season,
2020)
# U.C 9.5
def test_create_and_update_points_calculation_policy(self):
self.assertIsInstance(self.points_policy, PointsCalculationPolicy)
self.league_controller.create_points_policy(5, 0, -5)
self.league_controller.update_points_calculation_policy_in_league(
self.league.league_id,
self.policy_db.get_points_id_counter() - 1)
self.league = self.league_controller.get_league(self.league.league_id)
self.assertEqual(self.policy_db.get_points_id_counter() - 1,
self.league.points_calculation_policy)
self.league_controller.delete_points_calculation_policy(
self.policy_db.get_points_id_counter() - 1)
# U.C 9.6
def test_create_and_update_game_schedule_policy(self):
self.assertIsInstance(self.schedule_policy, GameSchedulePolicy)
self.league_controller.create_game_schedule_policy(
5, 5, GameAssigningPoliciesEnum.RANDOM)
self.league_controller.update_game_schedule_policy_in_league(
self.league.league_id,
self.policy_db.get_schedule_id_counter() - 1)
self.league = self.league_controller.get_league(self.league.league_id)
self.assertEqual(self.policy_db.get_schedule_id_counter() - 1,
self.league.game_schedule_policy)
self.league_controller.delete_schedule_calculation_policy(
self.policy_db.get_schedule_id_counter() - 1)
# U.C 9.8
def test_create_and_update_team_budget_policy(self):
self.assertIsInstance(self.budget_policy, TeamBudgetPolicy)
self.league_controller.create_team_budget_policy(10000)
self.league_controller.update_team_budget_policy_in_league(
self.league.league_id,
self.policy_db.get_budget_id_counter() - 1)
self.league = self.league_controller.get_league(self.league.league_id)
self.assertEqual(self.policy_db.get_budget_id_counter() - 1,
self.league.team_budget_policy)
self.league_controller.delete_budget_calculation_policy(
self.policy_db.get_budget_id_counter() - 1)
# U.U 9.9
def test_manage_union_budget(self):
self.team_controller.add_income_to_team('Real Madrid', 10000, 'income')
t1 = self.team_controller.get_team('Real Madrid')
self.team_controller.add_income_to_team("Barcelona", 2000, 'income')
t2 = self.team_controller.get_team("Barcelona")
organization = UnionOrganization()
union_controller = UnionController(organization, self.user_db,
self.team_db, 5000)
union_controller.add_team_to_union(t1.name)
union_controller.add_team_to_union(t2.name)
union_controller.add_income(10000, '')
self.assertEqual(10000, organization.balance)
# wrong value
self.assertRaises(ValueError, union_controller.add_income, -10000, '')
union_controller.add_expense(10000, '')
self.assertEqual(0, organization.balance)
# wrong value
self.assertRaises(ValueError, union_controller.add_expense, -10000, '')
self.assertIn(t2.name, organization.teams_in_union)
union_controller.collect_registration_fee()
self.assertEqual(5000, organization.balance)
self.assertIn(t1.name, organization.teams_in_union)
self.assertNotIn(t2.name, organization.teams_in_union)
self.user_controller.add_union_representor('Dor123', '12345678', 'Dor',
datetime(1990, 8, 8), 2000)
representor = self.user_controller.get_user_by_name('Dor123')
organization.add_employee_to_union(representor.user_id)
union_controller.pay_employees()
self.assertEqual(3000, organization.balance)
union_controller.remove_employee_from_union(representor.user_id)
union_controller.remove_team_from_union(t1.name)
self.user_controller.delete_signed_user(representor.user_id)
organization.reset_organization()
def test_add_signed_user(self):
signed_user_controller = SignedUserController()
signed_user_controller.add_guest("0.0.0.1")
signed_user_controller.add_guest("0.0.0.1")
d1 = datetime.datetime(2020, 4, 23)
d2 = datetime.datetime(1998, 4, 23)
signed_user_controller.add_signed_user("name_u1", "1234", "ro", d1,
"0.0.0.5")
signed_user_controller.add_signed_user("name_u2", "1234", "ro", d2,
"0.0.0.6")
self.assertIsNotNone(
signed_user_controller.get_signed_users().get("name_u1").user_id)
self.assertEqual(3, (signed_user_controller.get_guests().__len__()) +
(signed_user_controller.get_signed_users().__len__()))
class AcceptanceTestsReferee(TestCase):
# Preparation
game_db = MongoGameDB()
user_db = MongoUserDB()
team_db = MongoTeamDB()
game_event_db = MongoGameEventDB()
match_controller = MatchController(game_db, user_db, game_event_db,
team_db)
team_controller = TeamManagementController(team_db, user_db)
user_controller = SignedUserController(user_db)
d_now = datetime.now()
owner1 = None
owner2 = None
main_referee = None
referee = None
referee2 = None
referee3 = None
game1 = None
game2 = None
game_event = None
def setUp(self):
self.user_controller.add_team_owner('owner', '1234', 'owner',
datetime.now())
self.user_controller.add_team_owner('owner2', '1234', 'otherowner',
datetime.now())
self.owner1 = self.user_controller.get_user_by_name('owner')
self.owner2 = self.user_controller.get_user_by_name('owner2')
self.team_controller.open_new_team('team1', self.owner1.user_id)
self.team_controller.open_new_team('team2', self.owner2.user_id)
self.user_controller.add_referee(RefereeQualificationEnum.MAIN,
'S123', '12345678', 'Sas',
datetime(1990, 8, 8))
self.user_controller.add_referee(RefereeQualificationEnum.REGULAR,
'S12', '12345678', 'Sde',
datetime(1990, 8, 8))
self.user_controller.add_referee(RefereeQualificationEnum.MAIN, 'S13',
'12345678', 'Swqed',
datetime(1990, 8, 8))
self.user_controller.add_referee(RefereeQualificationEnum.REGULAR,
'S23', '12345678', 'Saf',
datetime(1990, 8, 8))
self.main_referee = self.user_controller.get_user_by_name('S123')
self.referee = self.user_controller.get_user_by_name('S12')
self.referee2 = self.user_controller.get_user_by_name('S13')
self.referee3 = self.user_controller.get_user_by_name('S23')
self.match_controller.add_game('team1', 'team2', self.d_now, '',
self.main_referee.user_id,
[self.referee.user_id])
self.game1 = self.match_controller.get_game(
self.game_db.get_id_counter() - 1)
self.match_controller.add_game('team1', 'team2', datetime(2021, 4, 23),
'', self.referee2.user_id, [])
self.game2 = self.match_controller.get_game(
self.game_db.get_id_counter() - 1)
self.match_controller.start_game(self.game1.game_id)
self.match_controller.add_event(self.game1.game_id,
self.main_referee.user_id,
EventTypeEnum.GOAL,
'Goal to home team',
datetime(2020, 4, 4), 90)
self.game_event = self.match_controller.get_event(
self.game_event_db.get_id_counter() - 1)
def tearDown(self):
self.match_controller.remove_event(self.game_event.event_id)
self.match_controller.remove_game(self.game2.game_id)
self.match_controller.remove_game(self.game1.game_id)
self.user_controller.delete_signed_user(self.referee3.user_id)
self.user_controller.delete_signed_user(self.referee2.user_id)
self.user_controller.delete_signed_user(self.referee.user_id)
self.user_controller.delete_signed_user(self.main_referee.user_id)
self.team_controller.delete_team('team1')
self.team_controller.delete_team('team2')
self.user_controller.delete_signed_user(self.owner1.user_id)
self.user_controller.delete_signed_user(self.owner2.user_id)
# UC 10.2
def test_watch_games(self):
# --- Referee want to see future assigned games ---
game_list = self.match_controller.show_ongoing_games_by_referee(
self.main_referee.user_id)
self.assertEqual(game_list[-1].game_id, self.game1.game_id)
# --- Referee want to see future assigned games without having any ---
game_list = self.match_controller.show_games_by_referee(
self.referee3.user_id)
self.assertEqual(len(game_list), 0)
# UC 10.3
def test_update_ongoing_game_events(self):
# Referee get list of games to choose from
game_list = self.match_controller.show_ongoing_games_by_referee(
self.main_referee.user_id)
game_chosen = game_list[0]
# Referee gets a list of game events to choose from
game_events_list = game_chosen.events
self.assertEqual(len(game_events_list), 1)
game_event_chosen = self.match_controller.get_event(
game_events_list[0])
# Update game event by user input
self.match_controller.edit_event(
game_event_chosen.event_id,
event_description='Red card for Oscar',
event_type=EventTypeEnum.RED_CARD,
date=datetime.now(),
min_in_game=20)
self.assertEqual(
self.match_controller.get_event(
self.game_event.event_id).event_description,
'Red card for Oscar')
self.assertEqual(
self.match_controller.get_event(
self.game_event.event_id).min_in_game, 20)
# --- Referee trying to add game event to ongoing game without being assigned to one ---
# Referee get list of games to choose from
game_list = self.match_controller.show_ongoing_games_by_referee(
self.referee2.user_id)
self.assertEqual(len(game_list), 0)
# UC 10.4
def test_update_finished_game_events(self):
self.match_controller.end_game(self.game1.game_id)
# Main referee get list of games to choose from
game_list = self.match_controller.show_games_by_referee(
self.main_referee.user_id)
game_chosen = game_list[0]
# Main referee gets a list of game events to choose from
game_events_list = game_chosen.events
self.assertEqual(len(game_events_list), 1)
game_event_chosen = self.match_controller.get_event(
game_events_list[0])
# Update game event by user input
self.match_controller.edit_event(
game_event_chosen.event_id,
event_type=EventTypeEnum.YELLOW_CARD,
event_description='Yellow card for Shahar',
date=self.d_now,
min_in_game=50)
self.assertEqual(
self.match_controller.get_event(
game_event_chosen.event_id).event_description,
'Yellow card for Shahar')
self.assertEqual(
self.match_controller.get_event(
game_event_chosen.event_id).min_in_game, 50)
# --- Normal referee trying to edit finished game events ---
# Referee get list of games to choose from
game_list = self.match_controller.show_games_by_referee(
self.referee.user_id)
self.assertEqual(len(game_list), 0)
class AcceptanceTestsOwnerManager(TestCase):
def setUp(self):
# Preparation
self.team_db = MongoTeamDB()
self.user_db = MongoUserDB()
self.team_control = TeamManagementController(self.team_db,
self.user_db)
self.user_controller = SignedUserController(self.user_db)
self.user_controller.add_team_owner('user_nam2', 'password', 'NameB',
date.datetime(1993, 1, 12))
self.owner = self.user_controller.get_user_by_name('user_nam2')
self.user_controller.add_team_owner('user_nam3', 'password', 'NameC',
date.datetime(1993, 1, 12))
self.add_owner = self.user_controller.get_user_by_name('user_nam3')
self.user_controller.add_team_owner('owner_with_team', 'password',
'owner', date.datetime(1993, 1, 1))
self.owner_with_team = self.user_controller.get_user_by_name(
'owner_with_team')
self.user_controller.add_team_manager('user_nam1', 'password', 'nameA',
date.datetime(1993, 1, 1))
self.manager = self.user_controller.get_user_by_name('user_nam1')
self.user_controller.add_team_manager('manager_with_team', 'password',
'manager',
date.datetime(1993, 1, 1))
self.manager_with_team = self.user_controller.get_user_by_name(
'manager_with_team')
self.user_controller.add_player('user_nam4', 'password', 'NameD',
date.datetime(1993, 1, 12))
self.p1 = self.user_controller.get_user_by_name('user_nam4')
self.user_controller.add_player('user_nam5', 'password', 'NameE',
date.datetime(1993, 1, 12))
self.p2 = self.user_controller.get_user_by_name('user_nam5')
self.team_control.open_new_team("Barca", self.owner.user_id)
self.team_control.open_new_team("ajax", self.owner_with_team.user_id)
self.team_control.add_manager_to_team('ajax',
self.manager_with_team.user_id)
def tearDown(self):
self.team_control.delete_team('Barca')
self.team_control.delete_team('ajax')
self.user_controller.delete_signed_user(self.owner.user_id)
self.user_controller.delete_signed_user(self.add_owner.user_id)
self.user_controller.delete_signed_user(self.owner_with_team.user_id)
self.user_controller.delete_signed_user(self.manager.user_id)
self.user_controller.delete_signed_user(self.manager_with_team.user_id)
self.user_controller.delete_signed_user(self.p1.user_id)
self.user_controller.delete_signed_user(self.p2.user_id)
""" Testing adding a new team member,list of members
and deletion of list and one member"""
# UC 6.1.1
"""Testing adding player info"""
def test_add_team_member_to_team(self):
# acceptance
test_team = self.team_control.get_team('Barca')
# add player
self.team_control.add_team_member_to_team("Barca", self.p1.user_id)
test_team = self.team_control.get_team('Barca')
self.assertTrue(self.p1.user_id in test_team.team_members)
# Message presented
# not acceptance
# add player not correct input will be will be in the GUI
# Message presented that values incorrect
# not acceptance
# adding team member already in a team
self.assertRaises(ValueError,
self.team_control.add_team_member_to_team, "Barca",
self.p1.user_id)
# UC 6.1.2
"""Testing edit player info"""
def test_update_asset_acceptance(self):
# acceptance
# Owner chose update a coach or player:
# The owner can update only attribute effected by the team
# owner choose edit certain team member
# Message presented are you sure
# If agrees updates
self.team_control.set_number_to_player(self.p1.user_id, "9")
self.p1 = self.user_controller.get_user_by_id(self.p1.user_id)
self.assertTrue(self.p1.role.number == "9")
self.team_control.set_position_to_player(self.p1.user_id, "9")
self.p1 = self.user_controller.get_user_by_id(self.p1.user_id)
self.assertTrue(self.p1.role.position == "9")
self.team_control.set_stadium_to_team("Barca", "Camp")
self.assertTrue(self.team_control.get_team("Barca").stadium == "Camp")
# Message presented
# not acceptance
# owner choose edit certain team member
# Message presented are you sure
# owner disagree nothing happened
# UC 6.1.3
"""Testing remove asset """
def test_remove_team_asset(self):
# acceptance
# add player
self.team_control.add_team_member_to_team("Barca", self.p2.user_id)
# preparation for UC
self.assertTrue(self.p2.user_id in self.team_control.get_team(
"Barca").team_members)
# owner goes to remove member
# Gui Ask if he is sure
# owner agree ,remove player
self.team_control.remove_team_member_from_team("Barca",
self.p2.user_id)
self.assertFalse(self.p2.user_id in self.team_control.get_team(
"Barca").team_members)
# not acceptance
self.team_control.add_team_member_to_team("Barca", self.p2.user_id)
# preparation for UC
self.assertTrue(self.p2.user_id in self.team_control.get_team(
"Barca").team_members)
# owner goes to remove member
# Gui Ask if he is sure
# owner disagree
self.assertTrue(self.p2.user_id in self.team_control.get_team(
"Barca").team_members)
# nothing happens
# UC 6.2 add Set team additional owner
def test_add_team_owner(self):
self.assertEqual(1, len(self.team_control.get_team_owners('Barca')))
# owner choose to add owner to the team
# user accept
self.team_control.add_owner_to_team("Barca", self.add_owner.user_id)
# message presented by gui
self.assertEqual(2, len(self.team_control.get_team_owners('Barca')))
# not acceptance
# manager trying to add owner that already in a team
self.assertRaises(ValueError, self.team_control.add_owner_to_team,
"Barca", self.owner_with_team.user_id)
# message presented
# UC 6.3 remove additional owner
def test_remove_owner_acceptance(self):
# preparation for UC
self.team_control.add_owner_to_team("Barca", self.add_owner.user_id)
# owner choose team manager in the team
# Gui ask if he is sure
self.team_control.remove_owner_from_team("Barca",
self.add_owner.user_id)
self.assertEqual(1, len(self.team_control.get_team_owners("Barca")))
def test_remove_owner_not_acceptance(self):
# Manager try to delete team without add owner
self.assertRaises(Exception, self.team_control.remove_owner_from_team,
"Barca", self.owner.user_id)
# Get Gui message says there is no manager to delete
# UC 6.4 add Set team Manager
def test_add_team_manager_acceptance(self):
# owner choose to add manager to the team
# user accept
self.team_control.add_manager_to_team("Barca", self.manager.user_id)
# message presented by gui
self.assertEqual(1, len(self.team_control.get_team_managers('Barca')))
def test_add_team_manager_not_acceptance(self):
# owner choose to add manager already has a Manager /owner role in a team
self.assertRaises(ValueError, self.team_control.add_manager_to_team,
"Barca", self.manager_with_team.user_id)
# The system dont allow to add the manager and present message
# UC 6.5 remove Team manager
def test_remove_team_manager_acceptance(self):
# preparation for UC
self.team_control.add_manager_to_team("Barca", self.manager.user_id)
# owner choose team manager in the team
# Gui ask if he is sure
self.team_control.remove_manager_from_team("Barca",
self.manager.user_id)
self.assertEqual(0, len(self.team_control.get_team_managers("Barca")))
def test_remove_team_manager_not_acceptance(self):
# Manager try to delete team without manger
self.assertRaises(ValueError,
self.team_control.remove_manager_from_team, "Barca",
self.manager.user_id)
# Get Gui message says there is no manager to delete
# UC 6.6.1 Close Team
def test_close_team_acceptance(self):
# Owner chose close team
test_team = self.team_control.get_team("Barca")
self.assertTrue(test_team.is_open)
# chose option to close
# GUI ask if you sure
self.team_control.close_team("Barca")
test_team = self.team_control.get_team("Barca")
self.assertFalse(test_team.is_open)
# message presented
# all the team get notify
def test_close_team_not_acceptance(self):
# Owner chose close team
test_team = self.team_control.get_team("Barca")
self.assertTrue(test_team.is_open)
# chose option to close
# GUI ask if you sure
# owner choose not to close
# nothing happen
# UC 6.6.1 Close Team
def test_open_team_acceptance(self):
# prepertion
self.team_control.close_team("Barca")
# Owner open close team
test_team = self.team_control.get_team("Barca")
self.assertFalse(test_team.is_open)
# chose option to open
# GUI ask if you sure
self.team_control.reopen_team("Barca")
test_team = self.team_control.get_team("Barca")
self.assertTrue(test_team.is_open)
# message presented
# all the team get notify
def test_open_team_not_acceptance(self):
# prepertion
self.team_control.close_team("Barca")
# Owner open close team
test_team = self.team_control.get_team("Barca")
self.assertFalse(test_team.is_open)
# chose option to open
# GUI ask if you sure
# owner choose not to open
# nothing happen
# UC 6.7.1 Add expanse
def test_add_income_acceptance(self):
# Owner chose add income
# fill in correct input
self.team_control.add_income_to_team("Barca", 500, "Sponsorship")
self.assertTrue("+,500, Sponsorship" in
self.team_control.get_team_incomes("Barca"))
# Message presented by GUI
def test_add_income_not_acceptance(self):
# Owner chose add income
# fill in incorrect input
self.assertRaises(ValueError, self.team_control.add_income_to_team,
"Barca", -500, "Sponsorship")
# Message presented by GUI
# UC 6.7.2 Add expanse
def test_add_expanse_acceptance(self):
# Owner chose add expanse
# fill in incorrect input
self.team_control.add_income_to_team("Barca", 500, "Sponsorship")
self.team_control.add_expanse_to_team("Barca", 499, "Sponsorship")
self.assertTrue("-,499, Sponsorship" in
self.team_control.get_team_expanses("Barca"))
# Message presented by GUI
def test_add_expanse_not_acceptance(self):
# Owner chose add expanse
# fill in incorrect input
self.assertRaises(ValueError, self.team_control.add_expanse_to_team,
"Barca", -500, "Sponsorship")
class AcceptanceTestsFan(TestCase):
# Preparation
user_db = MongoUserDB()
user_controller = SignedUserController(user_db)
page_db = MongoPageDB()
page_controller = PageController(page_db)
game_db = MongoGameDB()
game_event_db = MongoGameEventDB()
team_db = MongoTeamDB()
team_controller = TeamManagementController(team_db, user_db)
match_controller = MatchController(game_db, user_db, game_event_db,
team_db)
complaint_db = MongoComplaintDB()
complaint_controller = ComplaintController(complaint_db, user_db)
notification_controller = NotificationController(user_db, game_db)
team_owner1 = None
team_owner2 = None
referee = None
fan = None
game = None
page = None
team1 = None
team2 = None
def setUp(self):
self.user_controller.add_team_owner('owner', '1234', 'name',
date.datetime.now())
self.user_controller.add_team_owner('owner2', '1234', 'othername',
date.datetime.now())
self.user_controller.add_referee(RefereeQualificationEnum.MAIN,
'referee', '1234', 'referee',
date.datetime.now())
self.team_owner1 = self.user_controller.get_user_by_name('owner')
self.team_owner2 = self.user_controller.get_user_by_name('owner2')
self.referee = self.user_controller.get_user_by_name('referee')
self.team_controller.open_new_team('Hapoel beer sheva',
self.team_owner1.user_id)
self.team_controller.open_new_team('Maccabi Tel Aviv',
self.team_owner2.user_id)
self.match_controller.add_game('Hapoel beer sheva', 'Maccabi Tel Aviv',
date.datetime(2020, 4, 23), "",
self.referee.user_id)
self.game = self.match_controller.get_game(
self.game_db.get_id_counter() - 1)
self.user_controller.add_fan('fan', '1234', 'fan',
date.datetime(2020, 4, 23))
self.fan = self.user_controller.get_user_by_name('fan')
self.page_controller.add_page('MaorMelikson')
self.page = self.page_controller.get_page(
self.page_db.get_id_counter() - 1)
def tearDown(self):
self.team_controller.delete_team('Hapoel beer sheva')
self.team_controller.delete_team('Maccabi Tel Aviv')
self.user_controller.delete_signed_user(self.fan.user_id)
self.match_controller.remove_game(self.game.game_id)
self.page_controller.remove_page(self.page.page_id)
self.user_controller.delete_signed_user(self.team_owner1.user_id)
self.user_controller.delete_signed_user(self.team_owner2.user_id)
self.user_controller.delete_signed_user(self.referee.user_id)
# UC 3.2
# TODO: Implement and test
# def test_follow_page(self):
# # fan looks for the page MaorMelikson and the system retrieves it
# page = self.page_controller.search_personal_page('MaorMelikson')
# # fan follows the page
# self.fan.follow_page(page.page_id)
# self.assertEqual(page.page_id, self.fan.followed_pages[0])
#
# # the fan looks for the page GilSasover which is not in the page DB
# self.assertRaises(ValueError, self.page_controller.search_personal_page, 'GilSasover')
# UC 3.3 -> game status is missing in order to check this UC
def test_follow_game(self):
# fan looks for a game to follow and the system retrieves it
games = self.match_controller.all_games()
self.assertEqual(1, len(games))
# fan follows the chosen game
self.notification_controller.add_fan_follower_to_game(
self.fan.user_id, self.game.game_id)
# trying to follow same game twice
self.assertRaises(
ValueError, self.notification_controller.add_fan_follower_to_game,
self.fan.user_id, self.game.game_id)
self.fan = self.user_controller.get_user_by_id(self.fan.user_id)
self.assertEqual(self.game.game_id, self.fan.followed_games[0])
# UC 3.4
def test_complain(self):
self.complaint_controller.new_complaint('RoniLevi page is not correct',
self.fan.user_id)
self.fan = self.user_controller.get_user_by_id(self.fan.user_id)
self.assertEqual(self.fan.complaints[0],
self.complaint_db.get_id_counter() - 1)
# UC 3.5 -> no search history in fan yet
def test_show_history(self):
pass
# UC 3.6
def test_edit_personal_info(self):
# fan wants to edit his personal information
self.user_controller.edit_personal_data(self.fan.user_id,
'new_user_name', 'new_pass',
'idan',
date.datetime(2000, 1, 1))
self.fan = self.user_controller.get_user_by_id(self.fan.user_id)
self.assertEqual(self.fan.user_name, 'new_user_name')
self.assertEqual(self.fan.name, 'idan')
self.assertEqual(self.fan.birth_date, date.datetime(2000, 1, 1))
def test_get_user(self):
signed_user_controller = SignedUserController()
d1 = datetime.datetime(2020, 4, 23)
s = SignedUser("name_u1", "1234", "ro", d1, "0.0.0.5", 23)
signed_user_controller.add_user(s)
self.assertEqual(s, signed_user_controller.get_user(s.user_name))
class AcceptanceTestsSystemAdmin(TestCase):
# Preparation
user_db = MongoUserDB()
team_db = MongoTeamDB()
complaint_db = MongoComplaintDB()
user_controller = SignedUserController(user_db)
complaint_controller = ComplaintController(complaint_db, user_db)
team_controller = TeamManagementController(team_db, user_db)
fan = None
team_owner = None
system_admin = None
complaint = None
answer = 'complaint ans'
def setUp(self):
self.user_controller.add_team_owner('user_name', 'password', 'name',
date.datetime(1980, 5, 5))
self.team_owner = self.user_controller.get_user_by_name('user_name')
self.user_controller.add_fan('fan', '1234', 'name',
date.datetime(1993, 1, 9))
self.fan = self.user_controller.get_user_by_name('fan')
self.team_controller.open_new_team('Tiberias', self.team_owner.user_id)
self.complaint_controller.new_complaint('first comp', self.fan.user_id)
self.complaint = self.complaint_controller.get_complaint(
self.complaint_db.get_id_counter() - 1)
def tearDown(self):
self.team_controller.delete_team('Tiberias')
self.user_controller.delete_signed_user(self.team_owner.user_id)
self.user_controller.delete_signed_user(self.fan.user_id)
self.complaint_controller.delete_complaint(self.complaint.complaint_id)
# UC 1.1
def test_init_system(self):
"""we init the DataBase in set up function ^ """
d2 = date.datetime(1998, 4, 23)
self.user_controller.add_system_admin("admin", "1234", "ro", d2)
admin = self.user_controller.get_user_by_name('admin')
self.assertTrue(self.user_controller.confirm_user('admin', '1234'))
self.assertRaises(AssertionError,
self.user_controller.delete_signed_user,
admin.user_id)
self.user_db.delete_user(admin.user_id)
def test_init_system_no_acceptance(self):
"""we init the DataBase in set up function ^ """
d2 = date.datetime(1998, 4, 23)
self.assertRaises(ValueError, self.user_controller.add_system_admin,
"", "1234", "ro", d2)
# UC 8.1
def test_close_team(self):
"""admin is connected and chose what team he wants to close"""
all_teams = self.team_controller.get_all_teams()
self.assertEqual(len(all_teams), 1)
"""admin see only the team that in the system"""
"""if admin want to exit he press on exit and stop here"""
self.team_controller.close_team("Tiberias")
self.assertFalse(self.team_controller.get_team("Tiberias").is_open)
#UC 8.2
def test_remove_signed_user(self):
""" Admin in connected and want to close team """
d1 = date.datetime(2020, 4, 23)
d2 = date.datetime(1998, 4, 23)
self.user_controller.add_fan("name_u1", "1234", "ro", d1)
self.user_controller.add_fan("admin", "1234", "ro", d2)
fan = self.user_controller.get_user_by_name('name_u1')
fan2 = self.user_controller.get_user_by_name('admin')
self.user_controller.delete_signed_user(fan.user_id)
self.assertFalse(self.user_controller.confirm_user('name_u1', '1234'))
self.assertTrue(self.user_controller.confirm_user('admin', '1234'))
self.user_controller.delete_signed_user(fan2.user_id)
# UC 8.3
def test_show_complaint_and_respond(self):
# admin wants to see all user complaints
complaints = self.complaint_controller.show_complaints()
com = self.complaint_db.get_all()
self.assertEqual(com[0].answer, complaints[0].answer)
# admin chooses a complaint to answer on
self.complaint = self.complaint_controller.get_complaint(
complaints[0].complaint_id)
# admin responds to the complaint as he should
self.complaint_controller.respond_to_complaint(
self.answer, complaints[0].complaint_id)
self.complaint = self.complaint_controller.get_complaint(
complaints[0].complaint_id)
self.assertEqual(self.complaint.answer, self.answer)
