def test_store_same_users(ddb):
"""Test how database handles overwriting same user (same slack_id)."""
user = create_test_admin('abc_123')
user2 = create_test_admin('abc_123')
user2.name = 'Sprouts'
ddb.store(user)
ddb.store(user2)
assert ddb.retrieve(User, 'abc_123') == user2
def test_store_same_users(self):
"""Test how database handles overwriting same user (same slack_id)."""
user = create_test_admin('abc_123')
user2 = create_test_admin('abc_123')
user2.name = 'Sprouts'
self.assertTrue(self.ddb.store(user))
self.assertTrue(self.ddb.store(user2))
self.assertEqual(self.ddb.retrieve(User, 'abc_123'), user2)
def test_delete_user(self):
user = create_test_admin('abc_123')
self.assertTrue(self.ddb.store(user))
self.assertEqual(len(self.ddb.query(User)), 1)
self.ddb.delete(User, 'abc_123')
self.assertEqual(len(self.ddb.query(User)), 0)
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)
def setUp(self):
self.u = User('U12345')
self.admin = create_test_admin('Uadmin')
self.db = MemoryDB(users=[self.u, self.admin])
self.testcommand = TokenCommand(
self.db, TokenCommandConfig(timedelta(days=7), 'secret'))
def test_delete_user(ddb):
"""Test to see if we can successfully delete a user."""
user = create_test_admin('abc_123')
ddb.store(user)
assert len(ddb.query(User)) == 1
ddb.delete(User, 'abc_123')
assert len(ddb.query(User)) == 0
def test_store_retrieve_user(self):
"""Test to see if we can store and retrieve the same user."""
user = create_test_admin('abc_123')
success = self.ddb.store(user)
another_user = self.ddb.retrieve(User, 'abc_123')
self.assertTrue(success)
self.assertEqual(user, another_user)
def test_store_retrieve_user(ddb):
"""Test to see if we can store and retrieve the same user."""
user = create_test_admin('abc_123')
success = ddb.store(user)
another_user = ddb.retrieve(User, 'abc_123')
assert success
assert user == another_user
def test_bulk_retrieve_users(self):
uids = list(map(str, range(10)))
users = [create_test_admin(i) for i in uids]
for user in users:
self.assertTrue(self.ddb.store(user))
retrieved_users = self.ddb.bulk_retrieve(User, uids)
for user in retrieved_users:
self.assertIn(user, users)
def test_bulk_retrieve_users(ddb):
"""Test to see if we can store and bulk retrieve."""
uids = list(map(str, range(10)))
users = [create_test_admin(i) for i in uids]
for user in users:
assert ddb.store(user)
retrieved_users = ddb.bulk_retrieve(User, list(uids))
for user in retrieved_users:
assert user in users
def setUp(self):
self.app = Flask(__name__)
self.u0 = User('U0G9QF9C6')
self.u1 = User('Utheomadude')
self.admin = create_test_admin('Uadmin')
self.db = MemoryDB(users=[self.u0, self.u1, self.admin])
self.mock_github = mock.MagicMock(GithubInterface)
self.testcommand = UserCommand(self.db, self.mock_github, None)
self.maxDiff = None
def test_query_user(self):
"""Test to see if we can store and query the same user."""
user = create_test_admin('abc_123')
self.assertTrue(self.ddb.store(user))
users = self.ddb.query(User, [('permission_level', 'admin')])
strict_users = self.ddb.query(User, [('permission_level', 'admin'),
('slack_id', 'abc_123')])
all_users = self.ddb.query(User)
self.assertEqual(user, users[0])
self.assertEqual(user, all_users[0])
self.assertEqual(user, strict_users[0])
def test_query_user(ddb):
"""Test to see if we can store and query the same user."""
user = create_test_admin('abc_123')
assert ddb.store(user)
users = ddb.query(User, [('permission_level', 'admin')])
strict_users = ddb.query(User, [('permission_level', 'admin'),
('slack_id', 'abc_123')])
all_users = ddb.query(User)
assert user == users[0]
assert user == all_users[0]
assert user == strict_users[0]
def setUp(self):
self.app = Flask(__name__)
self.u0 = User('U0G9QF9C6')
self.u0.karma = KarmaCommand.karma_default_amount
self.u1 = User('UFJ42EU67')
self.u0.karma = KarmaCommand.karma_default_amount
self.admin = create_test_admin('Uadmin')
self.db = MemoryDB(users=[self.u0, self.u1, self.admin])
self.testcommand = KarmaCommand(self.db)
self.maxDiff = None
def test_query_or_lotsa_users(self):
uids = list(map(str, range(250)))
users = [create_test_admin(i) for i in uids]
# Bulk store to save on time
table_name = self.ddb.CONST.get_table_name(User)
table = self.ddb.ddb.Table(table_name)
with table.batch_writer() as batch:
for user in users:
batch.put_item(Item=User.to_dict(user))
params = [('slack_id', uid) for uid in uids]
queried_users = self.ddb.query_or(User, params)
self.assertCountEqual(queried_users, users)
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 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_query_or_users(self):
uids = list(map(str, range(10)))
users = [create_test_admin(i) for i in uids]
for user in users[:5]:
user.permissions_level = Permissions.member
for user in users:
self.assertTrue(self.ddb.store(user))
params = [('slack_id', str(uid)) for uid in uids]
queried_users = self.ddb.query_or(User, params)
for user in queried_users:
self.assertIn(user, users)
params = [('permissions_level', lvl) for lvl in ['admin', 'member']]
queried_users = self.ddb.query_or(User, params)
for user in queried_users:
self.assertIn(user, users)
def test_query_or_users(ddb):
"""Test to see if we can query users using union of parameters."""
uids = list(map(str, range(10)))
users = [create_test_admin(i) for i in uids]
for user in users[:5]:
user.permissions_level = Permissions.member
for user in users:
assert ddb.store(user)
params = [('slack_id', str(uid)) for uid in uids]
queried_users = ddb.query_or(User, params)
for user in queried_users:
assert user in users
params = [('permissions_level', lvl) for lvl in ['admin', 'member']]
queried_users = ddb.query_or(User, params)
for user in queried_users:
assert user in users
def setUp(self):
self.app = Flask(__name__)
self.config = mock.MagicMock()
self.gh = mock.MagicMock()
self.u0 = User('U123456789')
self.u1 = User('U234567891')
self.admin = create_test_admin('Uadmin')
self.t0 = Team("BRS", "brs", "web")
self.t1 = Team("OTEAM", "other team", "android")
self.t2 = Team("LEADS", "leads", "")
self.t3 = Team("ADMIN", "admin", "")
self.db = MemoryDB(users=[self.u0, self.u1, self.admin],
teams=[self.t0, self.t1, self.t2, self.t3])
self.sc = mock.MagicMock()
self.testcommand = TeamCommand(self.config, self.db, self.gh, self.sc)
self.help_text = self.testcommand.help
self.maxDiff = None
self.config.github_team_all = 'all'
self.config.github_team_leads = 'leads'
self.config.github_team_admin = 'admin'
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.admin = util.create_test_admin('Uadmin')
self.users = {u.slack_id: u for u in makeUsers(20)}
self.users['Uadmin'] = self.admin
self.teams = {t.github_team_id: t for t in makeTeams()}
def test_store_user(ddb):
"""Test storing user calls correct functions."""
dbf = DBFacade(ddb)
test_user = create_test_admin('abc_123')
dbf.store(test_user)
ddb.store.assert_called_with(test_user)
def test_valid_user():
"""Test the User static class method is_valid()."""
user = User("")
assert not User.is_valid(user)
user = create_test_admin("brussel-sprouts")
assert User.is_valid(user)
