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_authtoken_is_valid(self): """ Test for verifying if AuthToken's token is valid """ client = self.fixtures.client # scenario 1: when validity is unlimited (0) tomriddle = models.User(username=u'voldemort', fullname=u'Tom Riddle') scope = [u'id', u'email'] tomriddle_token = models.AuthToken(client=client, user=tomriddle, scope=scope, validity=0) self.assertTrue(tomriddle_token.is_valid()) # scenario 2: when validity has not been given draco = models.User(username=u'draco', fullname=u'Draco Malfoy') draco_token = models.AuthToken(client=client, user=draco, scope=scope) with self.assertRaises(TypeError): draco_token.is_valid() # scenario 3: when validity is limited harry = models.User(username=u'harry', fullname=u'Harry Potter') harry_token = models.AuthToken(client=client, user=harry, scope=scope, validity=3600, created_at=utcnow()) self.assertTrue(harry_token.is_valid()) # scenario 4: when validity is limited *and* the token has expired cedric = models.User(username=u'cedric', fullname=u'Cedric Diggory') cedric_token = models.AuthToken(client=client, user=cedric, scope=scope, validity=1, created_at=utcnow() - timedelta(1)) self.assertFalse(cedric_token.is_valid())
def test_authtoken_user(self): """ Test for checking AuthToken's user property """ crusoe = self.fixtures.crusoe client = self.fixtures.client user_session = models.UserSession(buid=buid(), user=crusoe) auth_token_with_user_session = models.AuthToken(user=crusoe, user_session=user_session) self.assertIsInstance(auth_token_with_user_session.user_session.user, models.User) self.assertEqual(auth_token_with_user_session.user_session.user, crusoe) auth_token_without_user_session = models.AuthToken(client=client, user=crusoe) self.assertIsInstance(auth_token_without_user_session._user, models.User) self.assertEqual(auth_token_without_user_session._user, crusoe)
def test_authtoken_refresh(self): """Test to verify creation of new token while retaining the refresh token.""" hagrid = models.User(username=u'hagrid', fullname=u'Rubeus Hagrid') auth_token = models.AuthToken(user=hagrid, algorithm='hmac-sha-1') existing_token = auth_token.token existing_secret = auth_token.secret auth_token.refresh() self.assertNotEqual(existing_token, auth_token.token) self.assertNotEqual(existing_secret, auth_token.secret)
def test_client_authtoken_for(self): """ Test for retrieving authtoken for this user and client (only confidential clients) """ # scenario 1: for a client that has confidential=True auth_client = self.fixtures.auth_client crusoe = self.fixtures.crusoe result = auth_client.authtoken_for(crusoe) client_token = models.AuthToken( auth_client=auth_client, user=crusoe, scope='id', validity=0 ) result = auth_client.authtoken_for(user=crusoe) self.assertEqual(client_token, result) self.assertIsInstance(result, models.AuthToken) assert result.user == crusoe # scenario 2: for a client that has confidential=False varys = models.User(username='******', fullname='Lord Varys') house_lannisters = models.AuthClient( title='House of Lannisters', confidential=False, user=varys, website='houseoflannisters.westeros', ) varys_session = models.UserSession( user=varys, ipaddr='192.168.1.99', user_agent='Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.110 Safari/537.36', accessed_at=utcnow(), ) lannisters_auth_token = models.AuthToken( auth_client=house_lannisters, user=varys, scope='throne', validity=0, user_session=varys_session, ) db.session.add_all( [varys, house_lannisters, lannisters_auth_token, varys_session] ) db.session.commit() result = house_lannisters.authtoken_for(varys, user_session=varys_session) self.assertIsInstance(result, models.AuthToken) assert "Lord Varys" == result.user.fullname
def test_scopemixin__scope_set(self): """Test to set scope with __scope_set on an AuthToken instance""" """Test to retrieve scope with __scope_get on an AuthToken instance """ scope = [u'teams', u'wars', u'alliances'] sansa = models.User(username=u'sansa', fullname=u'Sansa Stark') client = self.fixtures.client sansa_token = models.AuthToken(client=client, user=sansa, validity=0) sansa_token._scope_set(scope) db.session.add_all([sansa, sansa_token]) db.session.commit() self.assertEqual(sansa_token._scope_get(), tuple(sorted(scope)))
def test_AuthToken_init(self): """ Test for verifying creation of AuthToken instance note: Only one authtoken per user and client """ client = self.fixtures.client crusoe = self.fixtures.crusoe result = models.AuthToken(client=client, user=crusoe, scope=u'id', validity=0) self.assertIsInstance(result, models.AuthToken) self.assertEqual(result.user, crusoe) self.assertEqual(result.client, client)
def test_scopemixin__scope_get(self): """Test to retrieve scope with __scope_get on an AuthToken instance """ scope = ['teams', 'email', 'id'] khal = models.User(username='******', fullname='Khal Drogo') auth_client = self.fixtures.auth_client khal_token = models.AuthToken(auth_client=auth_client, user=khal, scope=scope, validity=0) db.session.add_all([khal, khal_token]) db.session.commit() self.assertEqual(khal_token._scope_get(), tuple(sorted(scope)))
def test_scopemixin_scope(self): """Test to retrieve scope on an ScopeMixin inherited class instance via scope method""" scope = 'tricks' ginny = models.User(username='******', fullname='Ginny Weasley') auth_client = self.fixtures.auth_client ginny_token = models.AuthToken(auth_client=auth_client, user=ginny, scope=scope, validity=0) db.session.add_all([ginny, ginny_token]) db.session.commit() self.assertEqual(ginny_token.scope, (scope, ))
def test_authtoken_algorithm(self): """ Test for checking AuthToken's algorithm property """ snape = models.User(username='******', fullname='Professor Severus Snape') valid_algorithm = 'hmac-sha-1' auth_token = models.AuthToken(user=snape) auth_token.algorithm = None self.assertIsNone(auth_token._algorithm) auth_token.algorithm = valid_algorithm self.assertEqual(auth_token._algorithm, valid_algorithm) self.assertEqual(auth_token.algorithm, valid_algorithm) with self.assertRaises(ValueError): auth_token.algorithm = "hmac-sha-2016"
def test_AuthToken_get(self): """ Test for retreiving a AuthToken instance given a token """ specialdachs = self.fixtures.specialdachs oakley = self.fixtures.oakley scope = [u'id'] dachsadv = models.Client(title=u"Dachshund Adventures", org=specialdachs, confidential=True, website=u"http://dachsadv.com") auth_token = models.AuthToken(client=dachsadv, user=oakley, scope=scope) token = auth_token.token db.session.add(dachsadv, auth_token) result = models.AuthToken.get(token) self.assertIsInstance(result, models.AuthToken) self.assertEqual(result.client, dachsadv)
def test_scopemixin__scope(self): """ Test to retrieve scope on an ScopeMixin inherited class instance via _scope method """ scope = 'id' bellatrix = models.User(username='******', fullname='Bellatrix Lestrange') auth_client = self.fixtures.auth_client bellatrix_token = models.AuthToken(auth_client=auth_client, user=bellatrix, scope=scope, validity=0) db.session.add_all([bellatrix, bellatrix_token]) db.session.commit() self.assertEqual(bellatrix_token._scope, scope)
def test_scopemixin_add_scope(self): """ Test for adding scope to a ScopeMixin inherited class instance """ scope1 = 'spells' scope2 = 'charms' neville = models.User(username='******', fullname='Neville Longbottom') auth_client = self.fixtures.auth_client neville_token = models.AuthToken(auth_client=auth_client, user=neville, validity=0, scope=scope1) db.session.add_all([neville, neville_token]) neville_token.add_scope(scope2) self.assertEqual(neville_token.scope, (scope2, scope1))
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, [])