def test_Organization_all(self):
"""
Test for getting all organizations (takes buid or name optionally)
"""
gryffindor = models.Organization(name=u'gryffindor')
ravenclaw = models.Organization(name=u'ravenclaw')
db.session.add(gryffindor)
db.session.add(ravenclaw)
db.session.commit()
# scenario 1: when neither buids nor names are given
self.assertEqual(models.Organization.all(), [])
# scenario 2: when buids are passed
orglist = [gryffindor, ravenclaw]
orgids = [gryffindor.buid, ravenclaw.buid]
all_by_buids = models.Organization.all(buids=orgids)
self.assertIsInstance(all_by_buids, list)
self.assertItemsEqual(all_by_buids, orglist)
# scenario 3: when org names are passed
names = [gryffindor.name, ravenclaw.name]
all_by_names = models.Organization.all(names=names)
self.assertIsInstance(all_by_names, list)
self.assertItemsEqual(all_by_names, orglist)
# scenario 4: when defercols is set to True for names
all_by_names_with_defercols = models.Organization.all(names=names)
self.assertIsInstance(all_by_names_with_defercols, list)
self.assertItemsEqual(all_by_names_with_defercols, orglist)
# scenario 5: when defercols is set to True for buids
all_by_buids_with_defercols = models.Organization.all(buids=orgids)
self.assertIsInstance(all_by_buids_with_defercols, list)
self.assertItemsEqual(all_by_buids_with_defercols, orglist)
def test_Organization_get(self):
"""
Test for retrieving an organization
"""
name = u'spew'
title = u'S.P.E.W'
spew = models.Organization(name=name, title=title)
db.session.add(spew)
db.session.commit()
# scenario 1: when neither name or buid are passed
with self.assertRaises(TypeError):
models.Organization.get()
# scenario 2: when buid is passed
buid = spew.buid
get_by_buid = models.Organization.get(buid=buid)
self.assertIsInstance(get_by_buid, models.Organization)
assert u'<Organization' in repr(get_by_buid)
assert u'"{title}">'.format(title=title) in repr(get_by_buid)
# scenario 3: when username is passed
get_by_name = models.Organization.get(name=name)
self.assertIsInstance(get_by_name, models.Organization)
assert u'<Organization {name} "{title}">'.format(name=name, title=title) in repr(get_by_name)
# scenario 4: when defercols is set to True
get_by_name_with_defercols = models.Organization.get(name=name, defercols=True)
self.assertIsInstance(get_by_name_with_defercols, models.Organization)
assert u'<Organization {name} "{title}">'.format(name=name, title=title) in repr(get_by_name_with_defercols)
def test_user_clients_with_team_access(self):
"""
Test to verify a list of clients with access to the user's organizations' teams.
"""
aro = models.User(username='******')
jane = models.User(username='******')
marcus = models.User(username='******')
volturi = models.Organization(name='volturi', title='The Volturi')
volturi.owners.users.append(aro)
volterra = models.AuthClient(
title='Volterra, Tuscany',
organization=volturi,
confidential=True,
website='volterra.co.it',
)
enforcers = models.AuthClient(
title='Volturi\'s thugs',
organization=volturi,
confidential=True,
website='volturi.co.it',
)
volterra_auth_token = models.AuthToken(auth_client=volterra,
user=aro,
scope='teams',
validity=0)
volterra_auth_token
enforcers_auth_token = models.AuthToken(auth_client=enforcers,
user=marcus,
scope='teams',
validity=0)
enforcers_auth_token
self.assertCountEqual(aro.clients_with_team_access(), [volterra])
self.assertCountEqual(marcus.clients_with_team_access(), [enforcers])
self.assertEqual(jane.clients_with_team_access(), [])
def test_organization_valid_name(self):
"""
Test for checking if given is a valid organization name
"""
hufflepuffs = models.Organization(name=u'hufflepuffs', title=u'Huffle Puffs')
self.assertFalse(hufflepuffs.valid_name(u'#$%#%___2836273untitled'))
self.assertTrue(hufflepuffs.valid_name(u'hufflepuffs'))
def test_organization_make_teams(self):
"""
Test for verifying the creation of default Teams: owners and members
"""
crusoe = self.fixtures.crusoe
oakley = self.fixtures.oakley
piglet = self.fixtures.piglet
name = u'dachshunited'
title = u'Dachshunds United'
dachsunited = models.Organization(name=name, title=title)
# Scenario: before any users were added to the organization
self.assertIsInstance(dachsunited.owners, models.Team)
self.assertIsInstance(dachsunited.members, models.Team)
self.assertEqual(dachsunited.owners.users.all(), [])
self.assertEqual(dachsunited.members.users.all(), [])
with self.assertRaises(TypeError):
dachsunited.members.get()
# After adding users to the organization
dachsunited.owners.users.append(crusoe)
dachsunited.members.users.append(oakley)
dachsunited.members.users.append(piglet)
assert u'<Team Owners of Organization {name} "{title}">'.format(
name=name, title=title) in repr(dachsunited.owners)
assert u'<Team Members of Organization {name} "{title}">'.format(
name=name, title=title) in repr(dachsunited.members)
def test_organization_pickername(self):
"""
Test for checking Organization's pickername
"""
# scenario 1: when only title is given
abnegation = models.Organization(title=u"Abnegation")
self.assertIsInstance(abnegation.pickername, unicode)
self.assertEqual(abnegation.pickername, abnegation.title)
# scenario 2: when both name and title are given
name = u'cullens'
title = u'The Cullens'
olympic_coven = models.Organization(title=title)
olympic_coven.name = name
db.session.add(olympic_coven)
db.session.commit()
self.assertIsInstance(olympic_coven.pickername, unicode)
assert u'{title} (@{name})'.format(title=title, name=name) in olympic_coven.pickername
def create_fixtures(self):
self.org = models.Organization(title=u"test", name=u"Test")
self.org.owners.users.append(self.user)
self.org1 = models.Organization(title=u"test1", name=u"Test1")
self.org1.owners.users.append(self.user)
self.client_team_access = models.ClientTeamAccess(
org=self.org,
client=self.client,
access_level=models.CLIENT_TEAM_ACCESS.ALL)
self.client_team_access1 = models.ClientTeamAccess(
org=self.org1,
client=self.client,
access_level=models.CLIENT_TEAM_ACCESS.ALL)
db.session.add_all([
self.org, self.org1, self.client_team_access,
self.client_team_access1
])
db.session.commit()
def create_fixtures(self):
self.org = models.Organization(title=u"title", name=u"Test")
self.org.owners.users.append(self.user)
db.session.add(self.org)
self.team = models.Team(userid=self.user.userid,
title=u"developers",
org=self.org)
db.session.add(self.team)
db.session.commit()
def test_Organization_init(self):
"""
Test for initializing a Organization instance
"""
name = u'dachshunited'
title = u'Dachshunds United'
dachsunited = models.Organization(name=name, title=title)
self.assertIsInstance(dachsunited, models.Organization)
self.assertEqual(dachsunited.title, title)
self.assertEqual(dachsunited.name, name)
def test_double_assigned_name(self):
"""
Names cannot be assigned to both a user and an organization simultaneously
"""
user = models.User(fullname="User")
org = models.Organization(title="Organization")
name = models.AccountName(name='double-assigned', user=user, organization=org)
db.session.add_all([user, org, name])
with self.assertRaises(IntegrityError):
db.session.commit()
def create_fixtures(self):
self.org = models.Organization(title=u"test", name=u"Test")
self.org.owners.users.append(self.user)
db.session.add(self.org)
self.permission = models.Permission(user=self.user,
org=self.org,
name=u"admin",
title=u"admin",
allusers=True)
db.session.add(self.permission)
db.session.commit()
def create_fixtures(self):
self.org = models.Organization(title=u"test", name=u"Test")
self.org.owners.users.append(self.user)
db.session.add(self.org)
self.team = models.Team(userid=self.user.userid,
title=u"developers",
org=self.org)
db.session.add(self.team)
self.team_client_permission = models.TeamClientPermissions(
team=self.team, client=self.client, access_permissions=u"admin")
db.session.add(self.team_client_permission)
db.session.commit()
def test_organization_name(self):
"""
Test for retrieving Organization's name
name is a setter method
"""
insurgent = models.Organization(title=u'Insurgent')
insurgent.name = u'35453496*%&^$%^'
self.assertIsNone(insurgent.name)
insurgent.name = u'Insurgent'
self.assertIsNone(insurgent.name)
insurgent.name = u'insurgent'
self.assertEqual(insurgent.name, u'insurgent')
def test_organization_name(self):
"""
Test for retrieving Organization's name
name is a setter method
"""
insurgent = models.Organization(title='Insurgent')
with self.assertRaises(ValueError):
insurgent.name = '35453496*%&^$%^'
with self.assertRaises(ValueError):
insurgent.name = 'Insurgent'
insurgent.name = 'insurgent'
self.assertEqual(insurgent.name, 'insurgent')
def test_organization_make_teams(self):
"""
Test for verifying the creation of default Teams: owners and members
"""
crusoe = self.fixtures.crusoe
name = 'dachshunited'
title = 'Dachshunds United'
dachsunited = models.Organization(name=name, title=title)
# Scenario: before any users were added to the organization
self.assertIsInstance(dachsunited.owners, models.Team)
self.assertEqual(dachsunited.owners.users.all(), [])
# After adding users to the organization
dachsunited.owners.users.append(crusoe)
self.assertEqual(dachsunited.owners.users.all(), [crusoe])
assert title == dachsunited.owners.organization.title
def test_AuthToken_all(self):
"""
Test for retreiving all AuthToken instances for given users
"""
client = self.fixtures.client
# scenario 1: When users passed are an instance of Query class
hermione = models.User(username=u'herminone',
fullname=u'Hermione Granger')
herminone_token = models.AuthToken(client=client,
user=hermione,
scope=[u'id'])
myrtle = models.User(username=u'myrtle', fullname=u'Moaning Myrtle')
myrtle_token = models.AuthToken(client=client,
user=myrtle,
scope=[u'id'])
alastor = models.User(username=u'alastor', fullname=u'Alastor Moody')
alastor_token = models.AuthToken(client=client,
user=alastor,
scope=[u'id'])
greyback = models.User(username=u'greyback',
fullname=u'Fenrir Greyback')
greyback_token = models.AuthToken(client=client,
user=greyback,
scope=[u'id'])
pottermania = models.Organization(name=u'Batdog', title=u'Batdog')
pottermania.owners.users.append(hermione)
pottermania_members = [hermione, alastor, greyback, myrtle]
for member in pottermania_members:
pottermania.members.users.append(member)
db.session.add_all([
myrtle, myrtle_token, hermione, herminone_token, alastor,
alastor_token, greyback, greyback_token, pottermania
])
db.session.commit()
# scenario 1 and count == 1
result1 = models.AuthToken.all(pottermania.owners.users)
self.assertIsInstance(result1, list)
self.assertIsInstance(result1[0], models.AuthToken)
self.assertItemsEqual(result1, [herminone_token])
# scenario 1 and count > 1
result2 = models.AuthToken.all(pottermania.members.users)
self.assertIsInstance(result2, list)
for each in result2:
self.assertIsInstance(each, models.AuthToken)
self.assertItemsEqual(
result2,
[herminone_token, alastor_token, greyback_token, myrtle_token])
# Scenario 2: When users passed are not an instance of Query class
lily = models.User(username=u'lily', fullname=u'Lily Evans Potter')
cho = models.User(username=u'cho', fullname=u'Cho Chang')
lily_token = models.AuthToken(client=client,
user=lily,
scope=[u'memories'])
cho_token = models.AuthToken(client=client,
user=cho,
scope=[u'charms'])
db.session.add_all([lily, lily_token, cho, cho_token])
db.session.commit()
# scenario 2 and count == 1
result3 = models.AuthToken.all([lily])
self.assertIsInstance(result3, list)
self.assertIsInstance(result3[0], models.AuthToken)
self.assertItemsEqual(result3, [lily_token])
# scenario 2 and count > 1
result4 = models.AuthToken.all([lily, cho])
self.assertIsInstance(result4, list)
for each in result4:
self.assertIsInstance(each, models.AuthToken)
self.assertItemsEqual(result4, [lily_token, cho_token])
# scenario 5: When user instances passed don't have any AuthToken against them
oakley = self.fixtures.oakley
piglet = self.fixtures.piglet
users = [piglet, oakley]
result5 = models.AuthToken.all(users)
self.assertListEqual(result5, [])
