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)
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)
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))
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)
from DataBases.MongoDB.MongoGameEventDB import MongoGameEventDB from DataBases.MongoDB.MongoPageDB import MongoPageDB from DataBases.MongoDB.MongoUnionOrganizationDB import MongoUnionOrganizationDB from Service.MatchController import MatchController from Service.SignedUserController import SignedUserController from Service.TeamManagementController import TeamManagementController from Service.UnionController import UnionController from Domain.UnionOrganization import UnionOrganization from Enums.RefereeQualificationEnum import RefereeQualificationEnum from Enums.EventTypeEnum import EventTypeEnum from Domain.Team import Team from datetime import datetime game_db = MongoGameDB() team_db = MongoTeamDB() user_db = MongoUserDB() complaint_db = MongoComplaintDB() game_event_db = MongoGameEventDB() league_db = MongoLeagueDB() page_db = MongoPageDB() season_db = MongoSeasonDB() union_org = MongoUnionOrganizationDB() game_db.reset_db() team_db.reset_db() user_db.reset_db() complaint_db.reset_db() game_event_db.reset_db() league_db.reset_db() page_db.reset_db() season_db.reset_db()
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()
from Service.NotificationsController import NotificationController
from DataBases.MongoDB.MongoUsersDB import MongoUserDB
from DataBases.MongoDB.MongoPolicyDB import MongoPolicyDB
from DataBases.MongoDB.MongoGameDB import MongoGameDB
from DataBases.MongoDB.MongoTeamDB import MongoTeamDB
from Enums.GameAssigningPoliciesEnum import GameAssigningPoliciesEnum
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))
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)
from DataBases.MongoDB.MongoUsersDB import MongoUserDB from DataBases.MongoDB.MongoTeamDB import MongoTeamDB from DataBases.MongoDB.MongoPolicyDB import MongoPolicyDB from DataBases.MongoDB.MongoSeasonDB import MongoSeasonDB from DataBases.MongoDB.MongoGameDB import MongoGameDB from DataBases.MongoDB.MongoGameEventDB import MongoGameEventDB from Service.SignedUserController import SignedUserController from Service.TeamManagementController import TeamManagementController from Enums.GameAssigningPoliciesEnum import GameAssigningPoliciesEnum from Enums.RefereeQualificationEnum import RefereeQualificationEnum 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)