def testAuthenticateFailsWithIncorrectPassword(self): """ L{authenticate} will be unsuccessful if the C{username} and the plaintext C{password} passed don't match a L{User} in the database. """ createUser(u'fred', u'fred-secret', u'Fred', u'*****@*****.**') self.assertRaises(AuthenticationError, authenticate, u'fred', u'bad-secret')
def testCreateUserWithDuplicateName(self): """ A L{DuplicateUserError} is raised if an attempt to create a L{User} with an existing username is made. """ createUser(u'username', u'password', u'User', u'*****@*****.**') self.assertRaises(DuplicateUserError, createUser, u'username', u'password', u'User', u'*****@*****.**')
def testAuthenticateFailsWithIncorrectPassword(self): """ L{authenticate} will be unsuccessful if the C{username} and the plaintext C{password} passed don't match a L{User} in the database. """ createUser(u'fred', u'fred-secret', u'Fred', u'*****@*****.**') self.assertRaises(AuthenticationError, authenticate, u'fred', u'bad-secret')
def testGetUsersByID(self): """ When L{User.id}s are provided L{getUsers} returns matching L{User}s. """ createUser(u'username1', u'password', u'User1', u'*****@*****.**') user = createUser(u'username2', u'password', u'User2', u'*****@*****.**') result = getUsers(ids=[user.id]) self.assertIdentical(user, result.one())
def testCreateUserWithDuplicateName(self): """ A L{DuplicateUserError} is raised if an attempt to create a L{User} with an existing username is made. """ createUser(u'username', u'password', u'User', u'*****@*****.**') self.assertRaises(DuplicateUserError, createUser, u'username', u'password', u'User', u'*****@*****.**')
def testGetUsersByID(self): """ When L{User.id}s are provided L{getUsers} returns matching L{User}s. """ createUser(u'username1', u'password', u'User1', u'*****@*****.**') user = createUser(u'username2', u'password', u'User2', u'*****@*****.**') result = getUsers(ids=[user.id]) self.assertIdentical(user, result.one())
def testCachingGetUserUsesTheCache(self): """L{getUser} adds missing L{User}s to the cache.""" createUser(u'user', u'password', u'User', u'*****@*****.**') user = self.getUser(u'user') self.assertIsInstance(user, User) # Delete the user from the store self.store.remove(user) user = self.getUser(u'user') self.assertIsInstance(user, User)
def testCreateOAuthConsumerGeneratesRandomSecret(self): """ L{createOAuthConsumer} generates a random secret each time an L{OAuthConsumer} is created. """ user1 = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') consumer1 = createOAuthConsumer(user1) user2 = createUser(u'user2', u'secret', u'User2', u'*****@*****.**') consumer2 = createOAuthConsumer(user2) self.assertNotEqual(consumer1.secret, consumer2.secret)
def testRequestAvatarIdWithIncorrectPassword(self): """ L{FacadeChecker.requestAvatarId} when passed credentials with an incorrect password must raise C{UnauthorizedLogin}. """ createUser(u'user', u'pass', u'User', u'*****@*****.**') self.store.commit() credentials = UsernamePassword('user', 'bad password') deferred = self.checker.requestAvatarId(credentials) return self.assertFailure(deferred, UnauthorizedLogin)
def testGet(self): """ L{UserAPI.get} returns the L{User}s that match the specified L{User.username}s. """ createUser(u'user1', u'secret', u'User 1', u'*****@*****.**') user = createUser(u'user2', u'secret', u'User 2', u'*****@*****.**') self.assertEqual({u'user2': {'id': user.objectID, 'name': u'User 2', 'role': Role.USER}}, self.users.get([u'user2']))
def testCachingGetUserUsesTheCache(self): """L{getUser} adds missing L{User}s to the cache.""" createUser(u'user', u'password', u'User', u'*****@*****.**') user = self.getUser(u'user') self.assertIsInstance(user, User) # Delete the user from the store self.store.remove(user) user = self.getUser(u'user') self.assertIsInstance(user, User)
def testCreateOAuthConsumerGeneratesRandomSecret(self): """ L{createOAuthConsumer} generates a random secret each time an L{OAuthConsumer} is created. """ user1 = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') consumer1 = createOAuthConsumer(user1) user2 = createUser(u'user2', u'secret', u'User2', u'*****@*****.**') consumer2 = createOAuthConsumer(user2) self.assertNotEqual(consumer1.secret, consumer2.secret)
def testGetTwitterUsers(self): """ L{getTwitterUsers} returns all L{TwitterUser}s in the database when no filtering options are provided. """ user1 = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') twitterUser1 = createTwitterUser(user1, 91845202) user2 = createUser(u'user2', u'secret', u'User2', u'*****@*****.**') twitterUser2 = createTwitterUser(user2, 198383) self.assertEqual([(user1, twitterUser1), (user2, twitterUser2)], list(getTwitterUsers().order_by(User.username)))
def testSet(self): """ L{PermissionAPI.set} updates existing permissions for the given values. """ user1 = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') user2 = createUser(u'user2', u'secret', u'User2', u'*****@*****.**') self.permissions.set([(u'username', Operation.CREATE_NAMESPACE, Policy.OPEN, [u'user1', u'user2'])]) namespace, permission = getNamespacePermissions([u'username']).one() self.assertEqual(Policy.OPEN, permission.createPolicy) self.assertEqual([user1.id, user2.id], permission.createExceptions)
def testGetOAuthConsumersFilteredByUserID(self): """ L{getOAuthConsumers} returns the L{User} and L{OAuthConsumer} instances that match the specified L{User.id}. """ user1 = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') consumer1 = createOAuthConsumer(user1) user2 = createUser(u'user2', u'secret', u'User2', u'*****@*****.**') createOAuthConsumer(user2) self.assertEqual((user1, consumer1), getOAuthConsumers(userIDs=[user1.id]).one())
def testGetOAuthConsumers(self): """ L{getOAuthConsumers} returns all L{OAuthConsumer}s in the database when no filtering options are provided. """ user1 = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') consumer1 = createOAuthConsumer(user1) user2 = createUser(u'user2', u'secret', u'User2', u'*****@*****.**') consumer2 = createOAuthConsumer(user2) self.assertEqual([(user1, consumer1), (user2, consumer2)], list(getOAuthConsumers().order_by(User.username)))
def testGetTwitterUsersFilteredByUID(self): """ L{getTwitterUsers} returns the L{User} and L{TwitterUser} instances that match the specified UID. """ user1 = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') twitterUser1 = createTwitterUser(user1, 91845202) user2 = createUser(u'user2', u'secret', u'User2', u'*****@*****.**') createTwitterUser(user2, 198383) self.assertEqual((user1, twitterUser1), getTwitterUsers(uids=[91845202]).one())
def testGetTwitterUsers(self): """ L{getTwitterUsers} returns all L{TwitterUser}s in the database when no filtering options are provided. """ user1 = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') twitterUser1 = createTwitterUser(user1, 91845202) user2 = createUser(u'user2', u'secret', u'User2', u'*****@*****.**') twitterUser2 = createTwitterUser(user2, 198383) self.assertEqual([(user1, twitterUser1), (user2, twitterUser2)], list(getTwitterUsers().order_by(User.username)))
def testGetOAuthConsumers(self): """ L{getOAuthConsumers} returns all L{OAuthConsumer}s in the database when no filtering options are provided. """ user1 = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') consumer1 = createOAuthConsumer(user1) user2 = createUser(u'user2', u'secret', u'User2', u'*****@*****.**') consumer2 = createOAuthConsumer(user2) self.assertEqual([(user1, consumer1), (user2, consumer2)], list(getOAuthConsumers().order_by(User.username)))
def testGetTwitterUsersFilteredByUID(self): """ L{getTwitterUsers} returns the L{User} and L{TwitterUser} instances that match the specified UID. """ user1 = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') twitterUser1 = createTwitterUser(user1, 91845202) user2 = createUser(u'user2', u'secret', u'User2', u'*****@*****.**') createTwitterUser(user2, 198383) self.assertEqual((user1, twitterUser1), getTwitterUsers(uids=[91845202]).one())
def testGetOAuthConsumersFilteredByUserID(self): """ L{getOAuthConsumers} returns the L{User} and L{OAuthConsumer} instances that match the specified L{User.id}. """ user1 = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') consumer1 = createOAuthConsumer(user1) user2 = createUser(u'user2', u'secret', u'User2', u'*****@*****.**') createOAuthConsumer(user2) self.assertEqual((user1, consumer1), getOAuthConsumers(userIDs=[user1.id]).one())
def testAuthenticateUserWithPasswordIncorrectPassword(self): """ L{FacadeAuthMixin.authenticateUserWithPassword} raises a L{TPasswordIncorrect} exception if the provided password doesn't match the L{User}'s. """ createUser(u'username', u'password', u'User', u'*****@*****.**') self.store.commit() deferred = self.facade.authenticateUserWithPassword('username', 'bad-password') return self.assertFailure(deferred, TPasswordIncorrect)
def testCreateUserDuplicate(self): """ L{FacadeAuthMixin.createUserWithPassword} will raise a L{TUserAlreadyExists} if the username given already exists in the database. """ createUser(u'fred', u'password', u'Fred', u'*****@*****.**') superuser = self.system.users[u'fluiddb'] self.store.commit() with login(u'fluiddb', superuser.objectID, self.transact) as session: deferred = self.facade.createUserWithPassword( session, 'fred', 'password', 'Fred', '*****@*****.**') yield self.assertFailure(deferred, TUserAlreadyExists)
def testRequestAvatarIdWithTokenMadeFromWrongSecret(self): """ L{FacadeOAuth2Checker.requestAvatarId} creates a L{FluidinfoSession} for the authenticated user only if the access token was created using the consumer's secret. """ user1 = createUser(u'user1', u'pass1', u'User1', u'*****@*****.**') createOAuthConsumer(user1, secret='secret16charlng1') user2 = createUser(u'user2', u'pass2', u'User2', u'*****@*****.**') self.store.commit() token = dataToToken('a' * 16, {'username': user2.username}) credentials = OAuth2Credentials(u'user1', u'pass1', token) deferred = self.checker.requestAvatarId(credentials) return self.assertFailure(deferred, UnauthorizedLogin)
def testGet(self): """ L{UserAPI.get} returns the L{User}s that match the specified L{User.username}s. """ createUser(u'user1', u'secret', u'User 1', u'*****@*****.**') user = createUser(u'user2', u'secret', u'User 2', u'*****@*****.**') self.assertEqual( { u'user2': { 'id': user.objectID, 'name': u'User 2', 'role': Role.USER } }, self.users.get([u'user2']))
def testAuthenticateUserWithOAuth2UnregisteredConsumer(self): """ L{FacadeAuthMixin.authenticateUserWithOAuth2} raises L{TPasswordIncorrect} if the consumer exists as a Fluidinfo user but is not registered as an OAuth consumer. """ createUser(u'user1', u'pass1', u'User1', u'*****@*****.**') createUser(u'user2', u'pass2', u'User2', u'*****@*****.**') self.store.commit() token = dataToToken('a' * 16, {'username': u'user2'}) credentials = OAuth2Credentials(u'user1', u'pass1', token) deferred = self.facade.authenticateUserWithOAuth2(credentials) return self.assertFailure(deferred, TPasswordIncorrect)
def _createUsers(self): """Create L{User}s.""" for userData in self._data['users']: user = createUser(userData['username'], userData['password'], userData['name'], userData['email'], userData['role']) self.users[user.username] = user
def testRequestAvatarIdInvalidToken(self): """ L{FacadeOAuthChecker.requestAvatarId} creates a L{FluidinfoSession} for the authenticated user only if the access token was properly formed (by calling dataToToken). """ secret = ''.join(sample(ALPHABET, 16)) user = createUser(u'username', u'password', u'User', u'*****@*****.**') createOAuthConsumer(user, secret=secret) self.store.commit() timestamp = 1314976811 headers = {'header1': 'foo'} arguments = 'argument1=bar' token = 'token' signature = 'wrong' nonce = 'nonce' credentials = OAuthCredentials('fluidinfo.com', user.username, token, 'HMAC-SHA1', signature, timestamp, nonce, 'GET', u'https://fluidinfo.com/foo', headers, arguments) deferred = self.checker.requestAvatarId(credentials) return self.assertFailure(deferred, UnauthorizedLogin)
def testCreateTwitterUserAddsToStore(self): """ L{createTwitterUser} adds the new L{TwitterUser} to the main store. """ user = createUser(u'username', u'secret', u'User', u'*****@*****.**') twitterUser = createTwitterUser(user, 91845202) self.assertIdentical(twitterUser, self.store.find(TwitterUser).one())
def testCreateNamespacePermissionWithTemplate(self): """ L{createNamespacePermission} can optionally use an existing L{NamespacePermission} as a template for the new one. """ user = createUser(u'name', u'password', u'Name', u'*****@*****.**') namespace1 = createNamespace(user, u'name1') permission1 = createNamespacePermission(namespace1) permission1.set(Operation.CREATE_NAMESPACE, Policy.OPEN, []) permission1.set(Operation.UPDATE_NAMESPACE, Policy.OPEN, []) permission1.set(Operation.DELETE_NAMESPACE, Policy.OPEN, []) permission1.set(Operation.LIST_NAMESPACE, Policy.CLOSED, [user.id]) permission1.set(Operation.CONTROL_NAMESPACE, Policy.OPEN, []) namespace2 = createNamespace(user, u'name2') permission2 = createNamespacePermission(namespace2, permission1) self.assertEqual((Policy.OPEN, []), permission2.get(Operation.CREATE_NAMESPACE)) self.assertEqual((Policy.OPEN, []), permission2.get(Operation.UPDATE_NAMESPACE)) self.assertEqual((Policy.OPEN, []), permission2.get(Operation.DELETE_NAMESPACE)) self.assertEqual((Policy.CLOSED, [user.id]), permission2.get(Operation.LIST_NAMESPACE)) self.assertEqual((Policy.OPEN, []), permission2.get(Operation.CONTROL_NAMESPACE))
def testCreateTagPermission(self): """ L{createTagPermission} creates a new L{TagPermission} using the system-wide default permission settings. """ user = createUser(u'name', u'password', u'Name', u'*****@*****.**') namespace = createNamespace(user, u'name') tag = createTag(user, namespace, u'tag') permission = createTagPermission(tag) self.assertNotIdentical(None, permission.tagID) self.assertEqual(tag.id, permission.tagID) self.assertEqual(Policy.CLOSED, permission.updatePolicy) self.assertEqual([user.id], permission.updateExceptions) self.assertEqual(Policy.CLOSED, permission.deletePolicy) self.assertEqual([user.id], permission.deleteExceptions) self.assertEqual(Policy.CLOSED, permission.controlPolicy) self.assertEqual([user.id], permission.controlExceptions) self.assertEqual(Policy.CLOSED, permission.writeValuePolicy) self.assertEqual([user.id], permission.writeValueExceptions) self.assertEqual(Policy.OPEN, permission.readValuePolicy) self.assertEqual([], permission.readValueExceptions) self.assertEqual(Policy.CLOSED, permission.deleteValuePolicy) self.assertEqual([user.id], permission.deleteValueExceptions) self.assertEqual(Policy.CLOSED, permission.controlValuePolicy) self.assertEqual([user.id], permission.controlValueExceptions)
def testCreateTagWithDefaultPermissions(self): """ L{createTagPermission} creates a default set of permissions based on the default L{Namespace}s with permissions. """ user = createUser(u'name', u'password', u'Name', u'*****@*****.**') namespace = createNamespace(user, u'name') createNamespacePermission(namespace) tag = createTag(user, namespace, u'tag') permission2 = createTagPermission(tag) self.assertEqual((Policy.CLOSED, [user.id]), permission2.get(Operation.UPDATE_TAG)) self.assertEqual((Policy.CLOSED, [user.id]), permission2.get(Operation.DELETE_TAG)) self.assertEqual((Policy.CLOSED, [user.id]), permission2.get(Operation.CONTROL_TAG)) self.assertEqual((Policy.CLOSED, [user.id]), permission2.get(Operation.WRITE_TAG_VALUE)) self.assertEqual((Policy.OPEN, []), permission2.get(Operation.READ_TAG_VALUE)) self.assertEqual((Policy.CLOSED, [user.id]), permission2.get(Operation.DELETE_TAG_VALUE)) self.assertEqual((Policy.CLOSED, [user.id]), permission2.get(Operation.CONTROL_TAG_VALUE))
def testCreateTagPermissionInheritsFromNamespace(self): """ L{createTagPermission} inherits permissions from its parent's L{NamespacePermission}s. """ user = createUser(u'name', u'password', u'Name', u'*****@*****.**') namespace = createNamespace(user, u'name') permission1 = createNamespacePermission(namespace) permission1.set(Operation.CREATE_NAMESPACE, Policy.OPEN, []) permission1.set(Operation.UPDATE_NAMESPACE, Policy.OPEN, []) permission1.set(Operation.DELETE_NAMESPACE, Policy.OPEN, []) permission1.set(Operation.LIST_NAMESPACE, Policy.CLOSED, [user.id]) permission1.set(Operation.CONTROL_NAMESPACE, Policy.OPEN, []) tag = createTag(user, namespace, u'tag') permission2 = createTagPermission(tag) self.assertEqual((Policy.OPEN, []), permission2.get(Operation.UPDATE_TAG)) self.assertEqual((Policy.OPEN, []), permission2.get(Operation.DELETE_TAG)) self.assertEqual((Policy.OPEN, []), permission2.get(Operation.CONTROL_TAG)) self.assertEqual((Policy.OPEN, []), permission2.get(Operation.WRITE_TAG_VALUE)) self.assertEqual((Policy.CLOSED, [user.id]), permission2.get(Operation.READ_TAG_VALUE)) self.assertEqual((Policy.OPEN, []), permission2.get(Operation.DELETE_TAG_VALUE)) self.assertEqual((Policy.OPEN, []), permission2.get(Operation.CONTROL_TAG_VALUE))
def _createUsers(self): """Create L{User}s.""" for userData in self._data['users']: user = createUser(userData['username'], userData['password'], userData['name'], userData['email'], userData['role']) self.users[user.username] = user
def testCreateNamespaceAddsToStore(self): """L{createNamespace} adds the new L{Namespace} to the main store.""" user = createUser(u'username', u'password', u'User', u'*****@*****.**') namespace = createNamespace(user, u'name') result = self.store.find(Namespace, Namespace.name == u'name') self.assertIdentical(namespace, result.one())
def testGetTags(self): """L{getTags} returns all L{Tag}s in the database, by default.""" user = createUser(u'username', u'password', u'User', u'*****@*****.**') user.namespaceID = createNamespace(user, user.username, None).id tag = createTag(user, user.namespace, u'name') self.assertEqual(tag, getTags().one())
def testUniqueFileIDAndValueID(self): """ An C{IntegrityError} is raised if an L{OpaqueValueLink} with the same fileID and valueID is added to the database. Duplicated C{tag_id} or C{file_id} can be added as long as the pair is unique. """ user = createUser(u'name', u'password', u'User', u'*****@*****.**') user.namespaceID = createNamespace(user, user.username, None).id tag = createTag(user, user.namespace, u'tag') value1 = TagValue(user.id, tag.id, uuid4(), None) value2 = TagValue(user.id, tag.id, uuid4(), None) self.store.add(value1) self.store.add(value2) self.store.flush() fileID1 = 'f' * 64 fileID2 = '0' * 64 self.store.add(OpaqueValue(fileID1, 'content1')) self.store.add(OpaqueValue(fileID2, 'content2')) # Add an initial link self.store.add(OpaqueValueLink(value1.id, fileID1)) # Add link with the same fileID but different valueID. It should work. self.store.add(OpaqueValueLink(value2.id, fileID1)) # Add link with the same valueID but different fileID. It should work. self.store.add(OpaqueValueLink(value1.id, fileID2)) self.store.flush() # Add link with same fileID and valueID. It should fail. self.store.add(OpaqueValueLink(value1.id, fileID1)) self.assertRaises(IntegrityError, self.store.flush) self.store.rollback()
def testCreateTwitterUserAddsToStore(self): """ L{createTwitterUser} adds the new L{TwitterUser} to the main store. """ user = createUser(u'username', u'secret', u'User', u'*****@*****.**') twitterUser = createTwitterUser(user, 91845202) self.assertIdentical(twitterUser, self.store.find(TwitterUser).one())
def testAuthenticateUserWithOAuthUnknownUsernameInToken(self): """ L{FacadeAuthMixin.authenticateUserWithOAuth} raises a L{TNoSuchUser} exception if the username in the token does not match an existing L{User}. """ user1 = createUser(u'user1', u'pass1', u'User1', u'*****@*****.**') oauthConsumer1 = createOAuthConsumer(user1, secret='secret16charlng1') self.store.commit() timestamp = 1314976811 headers = {'header1': 'foo'} arguments = 'argument1=bar' token = dataToToken(oauthConsumer1.secret, {'username': u'unknownUser'}) signature = '3MNZYSgsGftopjuwv3g2u5Q+MZM=' nonce = 'nonce' credentials = OAuthCredentials( 'fluidinfo.com', user1.username, token, u'HMAC-SHA1', signature, timestamp, nonce, 'GET', 'https://fluidinfo.com/foo', headers, arguments) deferred = self.facade.authenticateUserWithOAuth(credentials) return self.assertFailure(deferred, TNoSuchUser)
def testGet(self): """ L{TwitterUserAPI.get} returns the L{User} matching a specified Twitter UID, if one exists. """ user = createUser(u'user', u'secret', u'User', u'*****@*****.**') createTwitterUser(user, 1928745) self.assertIdentical(user, TwitterUserAPI().get(1928745))
def setUp(self): super(GetRecentActivityTest, self).setUp() self.user1 = createUser(u'user1', 'hash', u'User', u'*****@*****.**') self.user2 = createUser(u'user2', 'hash', u'User', u'*****@*****.**') self.user3 = createUser(u'user3', 'hash', u'User', u'*****@*****.**') self.user1.namespaceID = createNamespace(self.user1, self.user1.username, None).id self.user2.namespaceID = createNamespace(self.user2, self.user2.username, None).id self.user3.namespaceID = createNamespace(self.user3, self.user3.username, None).id self.user1tag1 = createTag(self.user1, self.user1.namespace, u'tag1') self.user1tag2 = createTag(self.user1, self.user1.namespace, u'tag2') self.user2tag1 = createTag(self.user2, self.user2.namespace, u'tag1') self.user2tag2 = createTag(self.user2, self.user2.namespace, u'tag2') self.user3tag1 = createTag(self.user3, self.user3.namespace, u'tag1') self.user3tag2 = createTag(self.user3, self.user3.namespace, u'tag2')
def testUnicodeSetValue(self): """A L{TagValue} can store a C{list} of C{unicode} values.""" objectID = uuid4() user = createUser(u'username', u'password', u'User', u'*****@*****.**') namespace = createNamespace(user, u'name') tag = createTag(user, namespace, u'tag') self.store.add(TagValue(user.id, tag.id, objectID, [u'foo', u'bar']))
def testFloatValue(self): """A L{TagValue} can store a C{float} value.""" objectID = uuid4() user = createUser(u'username', u'password', u'User', u'*****@*****.**') namespace = createNamespace(user, u'name') tag = createTag(user, namespace, u'tag') self.store.add(TagValue(user.id, tag.id, objectID, 42.1))
def setUp(self): super(TagValueIntegrityCheckerTest, self).setUp() self.system = createSystemData() self.user = createUser(u'user', u'pass', u'Name', u'*****@*****.**') self.parent = createNamespace(self.user, u'user', None) self.user.namespaceID = self.parent.id self.checker = TagValueIntegrityChecker() self.superuser = self.system.users[u'fluiddb']
def testAuthenticate(self): """ L{authenticate} will be successful if the C{username} and the plaintext C{password} passed match a L{User} in the database. """ user = createUser(u'fred', u'fred-secret', u'Fred', u'*****@*****.**') self.assertIdentical(user, authenticate(u'fred', u'fred-secret'))
def testCreateOAuthConsumerAddsToStore(self): """ L{createOAuthConsumer} adds the new L{OAuthConsumer} to the main store. """ user = createUser(u'user', u'secret', u'User', u'*****@*****.**') consumer = createOAuthConsumer(user) self.assertIdentical(consumer, self.store.find(OAuthConsumer).one())
def testCreateOAuthConsumerWithInvalidCustomSecret(self): """ L{createOAuthConsumer} raises a C{ValueError} if the custom secret is not exactly 16-characters long. """ user = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') self.assertRaises(ValueError, createOAuthConsumer, user, 'custom-secret')
def testCreateOAuthConsumerWithCustomSecret(self): """ L{createOAuthConsumer} will use a custom secret, when it's provided. """ secret = ''.join(sample(ascii_letters + digits, 16)) user = createUser(u'user1', u'secret', u'User1', u'*****@*****.**') consumer = createOAuthConsumer(user, secret) self.assertEqual(secret, consumer.secret)
def testCreateUser(self): """L{createUser} creates a new L{User}.""" user = createUser(u'username', u'password', u'User', u'*****@*****.**') self.assertEqual(u'username', user.username) self.assertEqual(Role.USER, user.role) self.assertNotIdentical(None, user.objectID) self.assertNotIdentical(None, user.creationTime)
def testCreateUserWithoutPassword(self): """ L{createUser} returns a disabled L{User.password} if no password is specified. """ user = createUser(u'username', None, u'User', u'*****@*****.**', Role.SUPERUSER) self.assertEqual('!', user.passwordHash)
def testCreateTagAddsToStore(self): """L{createTag} adds the new L{Tag} to the main store.""" user = createUser(u'username', u'password', u'User', u'*****@*****.**') user.namespaceID = createNamespace(user, user.username, None).id tag = createTag(user, user.namespace, u'tag') result = self.store.find(Tag, Tag.path == u'username/tag') self.assertIdentical(tag, result.one())
def testCreateNamespaceWithMalformedPath(self): """ L{createNamespace} raises a L{MalformedPathError} if an invalid path is provided. """ user = createUser(u'username', u'password', u'User', u'*****@*****.**') self.assertRaises(MalformedPathError, createNamespace, user, u'')
def testCreateTwitterUser(self): """ L{createTwitterUser} creates a new L{TwitterUser}, adds them to the database, and returns the new instance. """ user = createUser(u'username', u'secret', u'User', u'*****@*****.**') twitterUser = createTwitterUser(user, 91845202) self.assertIdentical(user, twitterUser.user) self.assertEqual(91845202, twitterUser.uid)
def testCreateOAuthConsumer(self): """ L{createOAuthConsumer} creates a new L{OAuthConsumer} with a secret for the specified L{User}. """ user = createUser(u'username', u'secret', u'User', u'*****@*****.**') consumer = createOAuthConsumer(user) self.assertIdentical(user, consumer.user) self.assertEqual(16, len(consumer.secret)) self.assertNotIdentical(None, consumer.secret)
def testCreateTag(self): """L{createTag} creates a new L{Tag}.""" user = createUser(u'username', u'password', u'User', u'*****@*****.**') user.namespaceID = createNamespace(user, user.username, None).id tag = createTag(user, user.namespace, u'tag') self.assertIdentical(user, tag.creator) self.assertIdentical(user.namespace, tag.namespace) self.assertEqual(u'username/tag', tag.path) self.assertEqual(u'tag', tag.name)
def testCreate(self): """ L{TwitterUserAPI.create} creates a new L{TwitterUser} to map a Twitter UID to an existing L{User}. """ user = createUser(u'user', u'secret', u'User', u'*****@*****.**') TwitterUserAPI().create(u'user', 19385982) sameUser, twitterUser = getTwitterUsers([19385982]).one() self.assertNotIdentical(None, twitterUser) self.assertIdentical(user, sameUser)
def testGetNamespacesWithObjectIDs(self): """ When L{Namespace.objectIDs}s are provided L{getNamespaces} returns matching L{Namespace}s. """ user = createUser(u'username', u'password', u'User', u'*****@*****.**') namespace = createNamespace(user, u'name') result = getNamespaces(objectIDs=[namespace.objectID]) self.assertIdentical(namespace, result.one())