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())
