def create_test_team(tid: str,
team_name: str,
display_name: str) -> Team:
"""
Create a test team with team name, and with all other attributes the same.
========== =============================
Property Preset
========== =============================
Github ``tid``
Name slug ``team_name``
Display ``display_name``
Platform slack
Members ['abc_123']
========== =============================
:param tid: The github ID associated with the team
:param team_name: The github team name slug
:param display_name: The github team name
:return: a filled-in team model (no empty strings)
"""
t = Team(tid, team_name, display_name)
t.platform = 'slack'
t.add_member('abc_123')
return t
def setUp(self):
self.team = 'rocket'
self.teamid = 395830
self.member = 'theflatearth'
self.memberid = 3058493
self.add_payload = mem_default_payload(self.team, self.teamid,
self.member, self.memberid)
self.rm_payload = mem_default_payload(self.team, self.teamid,
self.member, self.memberid)
self.empty_payload = mem_default_payload(self.team, self.teamid,
self.member, self.memberid)
self.add_payload['action'] = 'added'
self.rm_payload['action'] = 'removed'
self.empty_payload['action'] = ''
self.u = User('U4058409')
self.u.github_id = str(self.memberid)
self.u.github_username = self.member
self.t = Team(str(self.teamid), self.team, self.team.capitalize())
self.db = MemoryDB(users=[self.u], teams=[self.t])
self.gh = mock.Mock()
self.conf = mock.Mock()
self.conf.github_team_all = 'all'
self.webhook_handler = MembershipEventHandler(self.db, self.gh,
self.conf)
def mem_remove(self,
github_id: str,
selected_team: Team,
team_name: str) -> ResponseTuple:
"""Help membership function if payload action is removal."""
member_list = self._facade. \
query(User, [('github_user_id', github_id)])
slack_ids_string = ""
if len(member_list) == 1:
slack_id = member_list[0].slack_id
if selected_team.has_member(github_id):
selected_team.discard_member(github_id)
self._facade.store(selected_team)
logging.info(f"deleted slack user {slack_id} "
f"from {team_name}")
slack_ids_string += f" {slack_id}"
return (f"deleted slack ID{slack_ids_string} "
f"from {team_name}", 200)
else:
logging.error(f"slack user {slack_id} not in {team_name}")
return (f"slack user {slack_id} not in {team_name}", 200)
elif len(member_list) > 1:
logging.error("Error: found github ID connected to"
" multiple slack IDs")
return ("Error: found github ID connected to multiple"
" slack IDs", 200)
else:
logging.error(f"could not find user {github_id}")
return f"could not find user {github_id}", 200
def test_team_equality():
"""Test the Team class method __eq__() and __ne__()."""
team = Team("1", "brussel-sprouts", "Brussel Sprouts")
team2 = Team("1", "brussel-sprouts", "Brussel Sprouts")
team3 = Team("1", "brussel-trouts", "Brussel Trouts")
assert team == team2
assert team != team3
def setUp(self):
self.u0 = User('U0G9QF9C6')
self.u0.email = '*****@*****.**'
self.u0.github_id = '305834954'
self.u1 = User('Utheomadude')
self.u1.email = '*****@*****.**'
self.u1.github_id = '349850564'
self.admin = create_test_admin('Uadmin')
self.lead = User('Ualley')
self.lead.email = '*****@*****.**'
self.lead.github_id = '2384858'
self.lead.permissions_level = Permissions.team_lead
self.t0 = Team('305849', 'butter-batter', 'Butter Batters')
self.t0.add_member(self.u0.github_id)
self.t0.add_member(self.lead.github_id)
self.t0.add_team_lead(self.lead.github_id)
self.t1 = Team('320484', 'aqua-scepter', 'Aqua Scepter')
self.t1.add_member(self.u1.github_id)
self.t2 = Team('22234', 'tiger-dear', 'Shakespearean')
self.db = MemoryDB(users=[self.u0, self.u1, self.admin, self.lead],
teams=[self.t0, self.t1, self.t2])
self.cmd = ExportCommand(self.db)
class TestGCPUtils(TestCase):
def setUp(self):
self.u0 = User('U93758')
self.u0.github_id = '22343'
self.u0.github_username = '******'
self.u0.email = '*****@*****.**'
self.t0 = Team('465884', 'team-plasma', 'Team Plasma')
self.t0.add_member(self.u0.github_id)
self.t0.folder = 'oieasotbokneawsoieomieaomiewrsdoie'
self.t1 = Team('394783', 'team-rocket', 'Team Rocket')
self.t1.add_member(self.u0.github_id)
self.db = MemoryDB(users=[self.u0], teams=[self.t0, self.t1])
self.gcp = mock.MagicMock(GCPInterface)
def test_sync_user_email_perms(self):
sync_user_email_perms(self.gcp, self.db, self.u0)
self.gcp.ensure_drive_permissions.assert_called_once_with(
self.t0.github_team_name, self.t0.folder, [self.u0.email]
)
def test_sync_team_email_perms_bad_email(self):
self.u0.email = 'bad@[email protected]'
sync_team_email_perms(self.gcp, self.db, self.t0)
self.gcp.ensure_drive_permissions.assert_not_called()
def handle_added(self,
github_id: str,
github_username: str,
organization: str) -> ResponseTuple:
"""Help organization function if payload action is added."""
logging.info(f"user {github_username} added to {organization}")
all_name = self._conf.github_team_all
try:
# Try to add the user to the 'all' team if it exists
team_all = get_team_by_name(self._facade, all_name)
self._gh.add_team_member(github_username, team_all.github_team_id)
team_all.add_member(github_id)
self._facade.store(team_all)
except LookupError:
# If that team doesn't exist, make it exist
t_id = str(self._gh.org_create_team(self._conf.github_team_all))
self._gh.add_team_member(github_username, t_id)
logging.info(f'team {all_name} created for {organization}')
team = Team(t_id, all_name, all_name)
team.add_member(github_id)
self._facade.store(team)
except RuntimeError as e:
# If there are any other kinds of errors, we log it
logging.error(e)
return '', 200
logging.info(f'user {github_username} added to team {all_name}')
return f"user {github_username} added to {organization}", 200
def test_check_credentials_not_lead(self):
"""Test checking to see if user is lead for certain team."""
user = User("USFAS689")
user.github_id = "IDGithub"
team = Team("brussels", "team", "id")
team.add_member(user.github_id)
user.permissions_level = Permissions.team_lead
self.assertFalse(util.check_permissions(user, team))
def makeTeams() -> List[Team]:
t0 = Team('t0', 'TZ', 'T Zero Blasters')
t0.platform = 'iOS'
t0.team_leads = set(['u0', 'u1', 'u2'])
t0.members = set(['u0', 'u1', 'u2'])
t1 = Team('t1', 'T1', 'T 1 Blasters')
t1.platform = 'iOS'
t1.team_leads = set(['u0', 'u2'])
t1.members = set(['u0', 'u2', 'u3'])
return [t0, t1]
def test_update_team(ddb):
"""Test to see if we can update a team."""
t = Team('1', 'brussel-sprouts', 'Brussel Sprouts')
ddb.store(t)
t = ddb.retrieve(Team, '1')
t.add_member('abc_123')
t.add_member('123_abc')
ddb.store(t)
assert len(ddb.retrieve(Team, '1').members) == 2
def test_update_team(self):
"""Test to see if we can update a team."""
t = Team('1', 'brussel-sprouts', 'Brussel Sprouts')
self.assertTrue(self.ddb.store(t))
t = self.ddb.retrieve(Team, '1')
t.add_member('abc_123')
t.add_member('123_abc')
self.assertTrue(self.ddb.store(t))
self.assertEqual(len(self.ddb.retrieve(Team, '1').members), 2)
def test_handle_create_multiple_team_lookup_error(self):
"""Test project command create parser with mult team lookup error."""
team1 = Team("GTID1", "team-name1", "name1")
team2 = Team("GTID2", "team-name2", "name2")
team1.team_leads.add(user)
team2.team_leads.add(user)
self.mock_facade.query.return_value = [team1, team2]
self.assertTupleEqual(
self.testcommand.handle("project create repo-link team-name",
user),
("2 teams found with GitHub team name team-name", 200))
def setUpClass(cls):
# start Chrome
options = webdriver.ChromeOptions()
options.add_argument('headless')
try:
cls.client = webdriver.Chrome('F:/Programs/chromedriver_win32/chromedriver.exe',chrome_options=options)
except:
pass
# skip these tests if the browser could not be started
if cls.client:
# create the application
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
# suppress logging to keep unittest output clean
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel("ERROR")
# create the database and populate with some fake data
db.create_all()
email = cls.app.config['FLASK_ADMIN']
name = 'admin'
password = cls.app.config['FLASK_ADMIN_PASSWORD']
if Team.query.filter_by(email=email).count() < 1:
admin = Team(teamName=name, email=email, password=password)
db.session.add(admin)
db.session.commit()
new_team = Team(teamName='testTeam', email='test@team', password='******')
db.session.add(new_team)
db.session.commit()
new_user=User(userName='******')
new_activity = Activity(AID='998', team=new_team, starttime='2017-04-09 15:25',
endtime='2017-04-09 15:30', location="testLocation",
title="testActivity", content="testContent", managePerson="testManager",
managePhone=110, manageEmail='test@activity')
db.session.add_all([new_user,new_activity])
db.session.commit()
new_UserActivity=UserActivity(user=new_user,activity=new_activity,content='123')
db.session.add(new_UserActivity)
db.session.commit()
# start the Flask server in a thread
cls.server_thread = threading.Thread(target=cls.app.run,
kwargs={'debug': False})
cls.server_thread.start()
# give the server a second to ensure it is up
time.sleep(1)
def setUp(self):
self.u0 = User('U395474')
self.u0.github_id = '321132'
self.u1 = User('U85739')
self.u1.github_id = '000584'
self.u2 = User('U3048485')
self.u2.github_id = '11121'
self.t0 = Team('305738', 'some-team', 'Some Team')
self.t0.add_member(self.u0.github_id)
self.t0.add_member(self.u1.github_id)
self.t1 = Team('305849', 'some-team', 'Some Team')
self.db = MemoryDB(users=[self.u0, self.u1, self.u2], teams=[self.t0])
def setUp(self):
self.app = Flask(__name__)
self.u0 = User('U0G9QF9C6')
self.u1 = User('Utheomadude')
self.t0 = Team("BRS", "brs", "web")
self.t1 = Team("OTEAM", "other team", "android")
self.admin = create_test_admin('Uadmin')
self.db = MemoryDB(users=[self.u0, self.u1, self.admin],
teams=[self.t0, self.t1])
self.mock_github = mock.MagicMock(GithubInterface)
self.testcommand = UserCommand(self.db, self.mock_github, None)
self.maxDiff = None
def test_handle_mem_event_add_member(mock_logging, mem_add_payload):
"""Test that instances when members are added to the mem are logged."""
mock_facade = mock.MagicMock(DBFacade)
return_user = User("SLACKID")
return_team = Team("2723476", "rocket", "rocket")
return_team.add_member("SLACKID")
mock_facade.query.return_value = [return_user]
mock_facade.retrieve.return_value = return_team
webhook_handler = MembershipEventHandler(mock_facade)
rsp, code = webhook_handler.handle(mem_add_payload)
mock_facade.store.assert_called_once_with(return_team)
mock_logging.info.assert_called_once_with(("user Codertocat added "
"to rocket"))
assert rsp == "added slack ID SLACKID"
assert code == 200
def test_refresh_github_changed_success(self) -> None:
"""Test refresh team command API to edit teams."""
new_team1 = Team("1", "newgh1", "name1")
new_team1.add_member(self.regular_user.github_id)
self.mock_github.org_get_teams.return_value = [
new_team1,
self.team2,
self.team3,
self.team3_dup,
]
refreshed = self.testapi.team_refresh("admin")
self.assertTrue(refreshed)
self.team1.github_team_name = "newgh1"
self.team1.add_member(self.regular_user.github_id)
self.mock_facade.store.assert_called_once_with(self.team1)
def mem_added(self, github_id: str, selected_team: Team, team_name: str,
github_username: str) -> ResponseTuple:
"""Help membership function if payload action is added."""
member_list = self._facade.query(User, [('github_user_id', github_id)])
slack_ids_string = ""
if len(member_list) > 0:
selected_team.add_member(github_id)
self._facade.store(selected_team)
for member in member_list:
slack_id = member.slack_id
logging.info(f"user {github_username} added to {team_name}")
slack_ids_string += f" {slack_id}"
return f"added slack ID{slack_ids_string}", 200
else:
logging.error(f"could not find user {github_id}")
return f"could not find user {github_username}", 404
def setUp(self):
self.app = create_app('testing')
self.app.testing = True
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
new_user = User(userName='******', email='test@user', phone='123456')
new_team = Team(teamName='testTeam',
email='test@team',
password='******')
new_activity = Activity(AID='998',
team=new_team,
starttime='2017-04-09 15:25',
endtime='2017-04-09 15:30',
location="testLocation",
title="testActivity",
content="testContent",
managePerson="testManager",
managePhone=110,
manageEmail='test@activity')
new_message = Message(user=new_user,
activity=new_activity,
content='hao',
time='2017-04-09 15:30',
isRead=False)
db.session.add_all([new_user, new_team, new_activity, new_message])
db.session.commit()
def setUp(self):
self.u0 = User('U93758')
self.u0.github_id = '22343'
self.u0.github_username = '******'
self.u0.email = '*****@*****.**'
self.t0 = Team('465884', 'team-plasma', 'Team Plasma')
self.t0.add_member(self.u0.github_id)
self.t0.folder = 'oieasotbokneawsoieomieaomiewrsdoie'
self.t1 = Team('394783', 'team-rocket', 'Team Rocket')
self.t1.add_member(self.u0.github_id)
self.db = MemoryDB(users=[self.u0], teams=[self.t0, self.t1])
self.gcp = mock.MagicMock(GCPInterface)
def setUp(self):
self.username = '******'
self.gh_uid = 4738549
self.default_payload = org_default_payload(self.username, self.gh_uid)
self.add_payload = org_default_payload(self.username, self.gh_uid)
self.rm_payload = org_default_payload(self.username, self.gh_uid)
self.invite_payload = org_default_payload(self.username, self.gh_uid)
self.empty_payload = org_default_payload(self.username, self.gh_uid)
self.add_payload['action'] = 'member_added'
self.rm_payload['action'] = 'member_removed'
self.invite_payload['action'] = 'member_invited'
self.empty_payload['action'] = ''
self.u0 = User('U01234954')
self.u0.github_id = str(self.gh_uid)
self.u0.github_username = self.username
self.team_all = Team('1', 'all', 'Team all')
self.db = MemoryDB(users=[self.u0], teams=[self.team_all])
self.gh = mock.Mock()
self.conf = mock.Mock()
self.conf.github_team_all = 'all'
self.webhook_handler = OrganizationEventHandler(self.db, self.gh,
self.conf)
def setUp(self):
self.team = 'rocket'
self.teamid = 4934950
self.newteam = 'someteam'
self.newteamid = 4028940
self.created_payload = team_default_payload(self.newteam,
self.newteamid)
self.deleted_payload = team_default_payload(self.team, self.teamid)
self.edited_payload = team_default_payload(self.team, self.teamid)
self.added_to_repo_payload = team_default_payload(
self.team, self.teamid)
self.rm_from_repo_payload = team_default_payload(
self.team, self.teamid)
self.empty_payload = team_default_payload(self.team, self.teamid)
self.created_payload['action'] = 'created'
self.deleted_payload['action'] = 'deleted'
self.edited_payload['action'] = 'edited'
self.added_to_repo_payload['action'] = 'added_to_repository'
self.rm_from_repo_payload['action'] = 'removed_from_repository'
self.empty_payload['action'] = ''
self.t = Team(str(self.teamid), self.team, self.team.capitalize())
self.db = MemoryDB(teams=[self.t])
self.gh = mock.Mock()
self.conf = mock.Mock()
self.webhook_handler = TeamEventHandler(self.db, self.gh, self.conf)
def test_handle_create_permission_error(self):
"""Test project command create parser with permission error."""
team = Team("GTID", "team-name", "name")
self.mock_facade.query.return_value = [team]
self.assertTupleEqual(
self.testcommand.handle("project create repo-link team-name",
user),
(self.testcommand.permission_error, 200))
def facade_retrieve_side_effect(*args, **kwargs):
"""Return a side effect for the mock facade."""
if args[0] == Project:
return Project("GTID", [])
elif args[0] == Team:
return Team("GTID", "team-name", "display-name")
else:
return User(user)
def test_handle_create_multiple_team_lookup_error(self):
team1 = Team('GTID1', 'team-name', 'name1')
self.db.teams['GTID1'] = team1
self.assertTupleEqual(
self.testcommand.handle(
f'project create repo-link {self.t0.github_team_name}',
self.admin.slack_id),
('2 teams found with GitHub team name team-name', 200))
def setUp(self):
self.app = Flask(__name__)
self.u0 = User('U03548940')
self.u0.github_username = '******'
self.u0.github_id = '534593'
self.admin = create_test_admin('Uadmin')
self.p0 = create_test_project(
'GTID', ['https://github.com/ubclaunchpad/rocket2'])
self.p1 = create_test_project(
'', ['https://github.com/ubclaunchpad/rocket2'])
self.t0 = Team('GTID', 'team-name', 'name')
self.db = MemoryDB(users=[self.u0, self.admin],
teams=[self.t0],
projs=[self.p0, self.p1])
self.testcommand = ProjectCommand(self.db)
def test_handle_assign_assign_error(self):
"""Test project command assign with assignment error."""
self.mock_facade.retrieve.return_value = Project("GTID", [])
team = Team("GTID", "team-name", "display-name")
team.team_leads.add(user)
self.mock_facade.query.return_value = [team]
self.assertTupleEqual(
self.testcommand.handle("project assign ID team-name", user),
(self.testcommand.assigned_error, 200))
def test_handle_force_assign(self):
"""Test project command force assign."""
self.mock_facade.retrieve.return_value = Project("GTID", [])
team = Team("GTID", "team-name", "display-name")
team.team_leads.add(user)
self.mock_facade.query.return_value = [team]
self.assertTupleEqual(
self.testcommand.handle("project assign ID team-name -f", user),
("Project successfully assigned!", 200))
def test_handle_create_user_lookup_error(self):
"""Test project command create parser with no user lookup error."""
team = Team("GTID", "team-name", "name")
self.mock_facade.query.return_value = [team]
self.mock_facade.retrieve.side_effect = LookupError(
"user lookup error")
self.assertTupleEqual(
self.testcommand.handle("project create repo-link team-name",
user), ("user lookup error", 200))
def facade_retrieve_side_effect(*args, **kwargs):
"""Return a side effect for the mock facade."""
if args[0] == Project:
return Project("", [])
elif args[0] == Team:
team = Team("GTID", "team-name", "display-name")
return team
else:
raise LookupError("team lookup error")
