class GetTwitterUsersTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testGetTwitterUsersWithoutMatches(self):
"""
L{getTwitterUsers} returns an empty C{ResultSet} if there are no
matches for the specified Twitter UID.
"""
self.assertIdentical(None, getTwitterUsers(uids=[193874]).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 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())
class FacadeTest(FluidinfoTestCase):
"""
Simple tests of L{Facade} functionality that are not to do with user
creation or authentication.
"""
resources = [('config', ConfigResource()),
('log', LoggingResource()),
('store', DatabaseResource()),
('threadPool', ThreadPoolResource())]
def setUp(self):
super(FacadeTest, self).setUp()
factory = FluidinfoSessionFactory('API-9000')
self.transact = Transact(self.threadPool)
self.facade = Facade(self.transact, factory)
self.system = createSystemData()
@inlineCallbacks
def testCreateAnonymousSession(self):
"""
L{FacadeAuthMixin.createAnonymousSession} creates a
L{FluidinfoSession} for the anonymous user C{anon} so that anonymous
requests coming from the C{WSFE} can be correctly verified by the
L{Facade}.
"""
anon = self.system.users[u'anon']
self.store.commit()
session = yield self.facade.createAnonymousSession()
self.assertEqual('anon', session.auth.username)
self.assertEqual(anon.objectID, session.auth.objectID)
class CreateNamespaceTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testCreateNamespace(self):
"""L{createNamespace} creates a new L{Namespace}."""
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
namespace = createNamespace(user, u'name')
self.assertEqual(u'name', namespace.path)
self.assertEqual(u'name', namespace.name)
self.assertIdentical(None, namespace.parentID)
self.assertNotIdentical(None, namespace.objectID)
self.assertNotIdentical(None, namespace.creationTime)
self.assertIdentical(user, namespace.creator)
self.assertIdentical(None, namespace.parent)
self.assertIdentical(None, namespace.children.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 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())
class TagSchemaTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testUniquePathConstraint(self):
"""
An C{IntegrityError} is raised if a L{Tag} with a duplicate path is
added to the database.
"""
user = createUser(u'name', u'password', u'User', u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
self.store.add(Tag(user, user.namespace, u'name/tag', u'tag'))
self.store.flush()
self.store.add(Tag(user, user.namespace, u'name/tag', u'tag'))
self.assertRaises(IntegrityError, self.store.flush)
self.store.rollback()
def testUniqueObjectIDConstraint(self):
"""
An C{IntegrityError} is raised if a L{Tag} with a duplicate object ID
is added to the database.
"""
user = createUser(u'name', u'password', u'User', u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag1 = Tag(user, user.namespace, u'name/tag1', u'tag1')
self.store.add(tag1)
self.store.flush()
tag2 = Tag(user, user.namespace, u'name/tag2', u'tag2')
tag2.objectID = tag1.objectID
self.store.add(tag2)
self.assertRaises(IntegrityError, self.store.flush)
self.store.rollback()
class GetChildNamespacesTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testGetChildNamespaces(self):
"""
L{getChildNamespace} returns the child L{Namespace}s for the specified
parent paths.
"""
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
createNamespace(user, u'ignored')
parent = createNamespace(user, u'parent')
child = createNamespace(user, u'parent/child', parent.id)
self.assertEqual(child, getChildNamespaces([u'parent']).one())
def testGetChildNamespacesOnlyConsidersDirectDescendants(self):
"""
L{getChildNamespace} only returns L{Namespace}s that are direct
descendants of the specified parent paths.
"""
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
parent = createNamespace(user, u'parent')
child = createNamespace(user, u'parent/child', parent.id)
createNamespace(user, u'parent/child/grandchild', child.id)
self.assertEqual(child, getChildNamespaces([u'parent']).one())
class RootResourceTest(FluidinfoTestCase):
resources = [('config', ConfigResource()), ('log', LoggingResource()),
('store', DatabaseResource()),
('threadPool', ThreadPoolResource())]
def setUp(self):
super(RootResourceTest, self).setUp()
factory = FluidinfoSessionFactory('API-9000')
transact = Transact(self.threadPool)
createSystemData()
self.checker = AnonymousChecker()
self.checker.facadeClient = Facade(transact, factory)
getConfig().set('service', 'allow-anonymous-access', 'False')
@inlineCallbacks
def testAnonymousAccessDenied(self):
"""
L{FacadeAnonymousCheckerTest.requestAvatarId} returns
an C{UnauthorizedLogin} for access by the C{anon} user if the
C{allow-anonymous-access} configuration option is C{False}. The
C{UnauthorizedLogin} is the C{session} attribute in L{RootResource} and
must result in the C{getChild} method returning a
L{WSFEUnauthorizedResource} instance.
"""
self.store.commit()
session = yield self.checker.requestAvatarId(credentials=None)
self.assertTrue(isinstance(session, UnauthorizedLogin))
root = RootResource(self.checker.facadeClient, session)
request = FakeRequest()
root.getChild('/', request)
class GetOAuthConsumersTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testGetOAuthConsumersWithoutMatches(self):
"""
L{getOAuthConsumers} returns an empty C{ResultSet} if there are no
matches for the specified L{User.id}s.
"""
consumer = getOAuthConsumers(userIDs=[sys.maxint]).one()
self.assertIdentical(None, consumer)
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 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())
class CreateTagValueTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testCreateTagValue(self):
"""L{createTagValue} creates a new L{TagValue}."""
objectID = uuid4()
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag = createTag(user, user.namespace, u'name')
value = createTagValue(user.id, tag.id, objectID, 42)
self.assertIdentical(user, value.creator)
self.assertEqual(tag, value.tag)
self.assertEqual(objectID, value.objectID)
self.assertEqual(42, value.value)
def testCreateTagValueAddsToDatabase(self):
"""
L{createTagValue} automatically adds the new L{TagValue} to the
database.
"""
objectID = uuid4()
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag = createTag(user, user.namespace, u'name')
value = createTagValue(user.id, tag.id, objectID, 42)
self.assertIdentical(value, self.store.find(TagValue).one())
class GetNamespacePermissionsTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testGetNamespacePermissionsWithUnknownPaths(self):
"""
L{getNamespacePermissions} returns an empty C{ResultSet} if
L{Namespace}s and L{NamespacePermission}s matching the specified
L{Namespace.path}s are not available.
"""
self.assertEqual([], list(getNamespacePermissions([u'unknown'])))
def testGetNamespacePermissions(self):
"""
L{getNamespacePermissions} returns the L{Namespace}s and
L{NamespacePermission}s that match the specified L{Namespace.path}s.
"""
user = createUser(u'name', u'password', u'Name', u'*****@*****.**')
parentNamespace = createNamespace(user, u'name')
parentPermission = createNamespacePermission(parentNamespace)
childNamespace = createNamespace(user,
u'name/child',
parentID=parentNamespace.id)
createNamespacePermission(childNamespace)
self.assertEqual((parentNamespace, parentPermission),
getNamespacePermissions([u'name']).one())
class GetUserTest(GetUserTestMixin, FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def setUp(self):
super(GetUserTest, self).setUp()
self.getUser = getUser
class NamespaceAPITest(NamespaceAPITestMixin, FluidinfoTestCase):
resources = [('config', ConfigResource()), ('store', DatabaseResource())]
def setUp(self):
super(NamespaceAPITest, self).setUp()
self.system = createSystemData()
UserAPI().create([(u'username', u'password', u'User',
u'*****@*****.**')])
self.user = getUser(u'username')
self.namespaces = NamespaceAPI(self.user)
self.permissions = PermissionAPI(self.user)
def testCreateWithoutData(self):
"""
L{NamespaceAPI.create} returns an empty C{list} if no L{Namespace}
data is available.
"""
result = self.namespaces.create([])
self.assertEqual([], result)
ignored = (self.system.namespaces.keys() +
[u'username', u'username/private'])
result = self.store.find(Namespace, Not(Namespace.path.is_in(ignored)))
self.assertIdentical(None, result.one())
def testPermissionsAreNotCreatedIfCreateFails(self):
"""
If L{NamespaceAPI.create} fails, no permissions should be created.
"""
self.assertRaises(MalformedPathError, self.namespaces.create,
[(u'!!!!/test', u'description')])
result = getNamespacePermissions([u'username/test'])
self.assertTrue(result.is_empty())
class NamespaceSchemaTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testUniquePathConstraint(self):
"""
An C{IntegrityError} is raised if a L{Namespace} with a duplicate name
is added to the database.
"""
user = User(u'name', 'password-hash', u'User', u'*****@*****.**',
Role.USER)
self.store.add(user)
self.store.add(Namespace(user, u'name', u'name'))
self.store.flush()
self.store.add(Namespace(user, u'name', u'name'))
self.assertRaises(IntegrityError, self.store.flush)
self.store.rollback()
def testUniqueObjectIDConstraint(self):
"""
An C{IntegrityError} is raised if a L{Namespace} with a duplicate
object ID is added to the database.
"""
user = User(u'name', 'password-hash', u'User', u'*****@*****.**',
Role.USER)
self.store.add(user)
namespace1 = Namespace(user, u'name1', u'name1')
self.store.add(namespace1)
self.store.flush()
namespace2 = Namespace(user, u'name2', u'name2')
namespace2.objectID = namespace1.objectID
self.store.add(namespace2)
self.assertRaises(IntegrityError, self.store.flush)
self.store.rollback()
class SecureRecentActivityAPIWithBrokenCacheTest(RecentActivityAPITestMixin,
FluidinfoTestCase):
resources = [('cache', BrokenCacheResource()), ('client', IndexResource()),
('config', ConfigResource()), ('log', LoggingResource()),
('store', DatabaseResource())]
def setUp(self):
super(SecureRecentActivityAPIWithBrokenCacheTest, self).setUp()
createSystemData()
UserAPI().create([(u'user', u'secret', u'User', u'*****@*****.**')])
self.user = getUser(u'user')
self.recentActivity = SecureRecentActivityAPI(self.user)
def getObjectAPI(self, user):
"""Get an L{CachingObjectAPI} instance for the specified user.
@param user: The L{User} to configure the L{CachingObjectAPI}
instance.
@return: An L{CachingObjectAPI} instance.
"""
return CachingObjectAPI(user)
def getTagValueAPI(self, user):
"""Get a L{TagValueAPI} instance for the specified user.
@param user: The L{User} to configure the L{TagValueAPI} instance.
@return: A L{TagValueAPI} instance.
"""
return CachingTagValueAPI(user)
class GetTagValuesTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testGetTagValues(self):
"""
L{getTagValues} returns all L{TagValue}s in the database, by default.
"""
objectID1 = uuid4()
objectID2 = uuid4()
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag = createTag(user, user.namespace, u'name')
value1 = self.store.add(TagValue(user.id, tag.id, objectID1, None))
value2 = self.store.add(TagValue(user.id, tag.id, objectID2, 42))
self.assertEqual(sorted([value1, value2]), sorted(getTagValues()))
def testGetTagValuesWithTagIDsAndObjectIDs(self):
"""
When C{(Tag.id, object ID)} 2-tuples are provided L{getTagValues}
returns matching L{TagValue}s.
"""
objectID1 = uuid4()
objectID2 = uuid4()
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag = createTag(user, user.namespace, u'name')
value = self.store.add(TagValue(user.id, tag.id, objectID1, None))
self.store.add(TagValue(user.id, tag.id, objectID2, 42))
self.assertEqual(value, getTagValues([(objectID1, tag.id)]).one())
class AboutTagValueSchemaTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testUniqueAboutTagValue(self):
"""
An C{IntegrityError} is raised if an L{AboutTagValue} with a duplicate
about tag value is added to the database.
"""
objectID1 = uuid4()
objectID2 = uuid4()
self.store.add(AboutTagValue(objectID1, u'foo'))
self.store.flush()
self.store.add(AboutTagValue(objectID2, u'foo'))
self.assertRaises(IntegrityError, self.store.flush)
self.store.rollback()
def testUniqueObjectID(self):
"""
An C{IntegrityError} is raised if an L{AboutTagValue} with a duplicate
object ID is added to the database.
"""
objectID = uuid4()
self.store.add(AboutTagValue(objectID, u'foo'))
self.store.flush()
self.store.add(AboutTagValue(objectID, u'bar'))
self.assertRaises(IntegrityError, self.store.flush)
self.store.rollback()
class RecentActivityAPITest(RecentActivityAPITestMixin, FluidinfoTestCase):
resources = [('config', ConfigResource()), ('store', DatabaseResource())]
def setUp(self):
super(RecentActivityAPITest, self).setUp()
createSystemData()
self.recentActivity = RecentActivityAPI()
UserAPI().create([(u'user', u'secret', u'User', u'*****@*****.**')])
self.user = getUser(u'user')
def getObjectAPI(self, user):
"""Get an L{ObjectAPI} instance for the specified user.
@param user: The L{User} to configure the L{ObjectAPI} instance.
@return: An L{ObjectAPI} instance.
"""
return ObjectAPI(user)
def getTagValueAPI(self, user):
"""Get a L{TagValueAPI} instance for the specified user.
@param user: The L{User} to configure the L{TagValueAPI} instance.
@return: A L{TagValueAPI} instance.
"""
return TagValueAPI(user)
class AuthenticateTest(FluidinfoTestCase):
resources = [('cache', CacheResource()), ('config', ConfigResource()),
('store', DatabaseResource())]
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 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 testAuthenticateFailsWithUnknownUser(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.
"""
error = self.assertRaises(UnknownUserError, authenticate, u'unknown',
u'bad-secret')
self.assertEqual([u'unknown'], error.usernames)
class DeleteCommentTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testDeleteComment(self):
"""
L{deleteComment} removes a L{Comment} object and its related
L{CommentObjectLink} objects.
"""
commentID = uuid4()
target1 = uuid4()
target2 = uuid4()
createAboutTagValue(target1, u'target1')
createAboutTagValue(target2, u'target2')
timestamp = datetime.now()
createComment(commentID, [target1, target2], u'username', timestamp)
self.assertEqual(1, deleteComment(commentID))
# The entry in the comments table must be gone.
result = self.store.find(Comment, Comment.objectID == commentID)
self.assertTrue(result.is_empty())
# The entries in the comment object link table must be gone.
result = self.store.find(CommentObjectLink,
CommentObjectLink.commentID == commentID)
self.assertTrue(result.is_empty())
def testDeleteNonexistentComment(self):
"""
L{deleteComment} must return C{0} when asked to remove a L{Comment}
that does not exist.
"""
commentID = uuid4()
self.assertEqual(0, deleteComment(commentID))
class CreateTagTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
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 testCreateTagWithMalformedPath(self):
"""
L{createTag} raises a L{MalformedPathError} if an invalid path is
provided.
"""
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
self.assertRaises(MalformedPathError, createTag, user, user.namespace,
u'')
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())
class GetObjectsIDsTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testGetObjectIDsWithoutData(self):
"""
L{getObjectIDs} doesn't return any results if no paths are provided.
"""
self.assertEqual([], list(getObjectIDs([])))
def testGetObjectIDsWithUnknownObjectID(self):
"""
L{getObjectIDs} doesn't return any results if unknown tag paths are
provided.
"""
user = createUser(u'user', u'secret', u'User', u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag = createTag(user, user.namespace, u'name1')
createTagValue(user.id, tag.id, uuid4(), 42)
self.assertEqual([], list(getObjectIDs([u'user/name2'])))
def testGetObjectIDs(self):
"""
L{getObjectIDs} returns a sequence of object IDs that match the
specified paths.
"""
objectID1 = uuid4()
user = createUser(u'user', u'secret', u'User', u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag1 = createTag(user, user.namespace, u'name1')
tag2 = createTag(user, user.namespace, u'name2')
createTagValue(user.id, tag1.id, objectID1, 42)
createTagValue(user.id, tag2.id, uuid4(), 17)
self.assertEqual(objectID1, getObjectIDs([u'user/name1']).one())
class SecureNamespaceAPIWithSuperuserTest(FluidinfoTestCase):
resources = [('cache', CacheResource()), ('config', ConfigResource()),
('store', DatabaseResource())]
def setUp(self):
super(SecureNamespaceAPIWithSuperuserTest, self).setUp()
system = createSystemData()
user = system.users[u'fluiddb']
self.namespaces = SecureNamespaceAPI(user)
self.permissions = CachingPermissionAPI(user)
def testCreateIsAllowed(self):
"""
Creating a new L{Namespace} should be allowed if we're a user with a
L{Role.SUPERUSER} no matter what permissions we have.
"""
values = [(u'fluiddb', Operation.CREATE_NAMESPACE, Policy.CLOSED, [])]
self.permissions.set(values)
result = self.namespaces.create([(u'fluiddb/test', u'description')])
self.assertEqual(1, len(result))
def testDeleteIsAllowed(self):
"""
Deleting a L{Namespace} should be allowed if we're a user with a
L{Role.SUPERUSER} no matter what permissions we have.
"""
result1 = self.namespaces.create([(u'fluiddb/test', u'description')])
values = [(u'fluiddb/test', Operation.DELETE_NAMESPACE, Policy.CLOSED,
[])]
self.permissions.set(values)
result2 = self.namespaces.delete([u'fluiddb/test'])
self.assertEqual(result1, result2)
def testSetIsAllowed(self):
"""
Updating a L{Namespace} should be allowed if we're a user with a
L{Role.SUPERUSER} no matter what permissions we have.
"""
self.namespaces.create([(u'fluiddb/test', u'description')])
values = [(u'fluiddb/test', Operation.UPDATE_NAMESPACE, Policy.CLOSED,
[])]
self.permissions.set(values)
self.namespaces.set({u'fluiddb/test': u'new description'})
def testGetIsAllowed(self):
"""
Getting information about a L{Namespace} should be allowed if we're a
user with a L{Role.SUPERUSER} no matter what permissions we have.
"""
self.namespaces.create([(u'fluiddb/test', u'description')])
values = [(u'fluiddb/test', Operation.LIST_NAMESPACE, Policy.CLOSED,
[])]
self.permissions.set(values)
result = self.namespaces.get([u'fluiddb'],
withDescriptions=False,
withTags=True,
withNamespaces=True)
self.assertEqual(1, len(result))
class UserAPITest(UserAPITestMixin, FluidinfoTestCase):
resources = [('config', ConfigResource()), ('store', DatabaseResource())]
def setUp(self):
super(UserAPITest, self).setUp()
self.system = createSystemData()
self.users = UserAPI()
class TouchObjectsTest(FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def testTouchObjects(self):
"""L{touchObjects} adds the objects to the C{dirty_objects} table."""
objectID = uuid4()
touchObjects([objectID])
self.assertNotIdentical(None, getDirtyObjects([objectID]).one())
class CachingUserAPIWithBrokenCacheTest(UserAPITestMixin, FluidinfoTestCase):
resources = [('cache', BrokenCacheResource()),
('config', ConfigResource()), ('log', LoggingResource()),
('store', DatabaseResource())]
def setUp(self):
super(CachingUserAPIWithBrokenCacheTest, self).setUp()
self.system = createSystemData()
self.users = CachingUserAPI()
class ObjectAPITest(ObjectAPITestMixin, FluidinfoTestCase):
resources = [('client', IndexResource()), ('config', ConfigResource()),
('store', DatabaseResource())]
def setUp(self):
super(ObjectAPITest, self).setUp()
self.system = createSystemData()
UserAPI().create([(u'user', u'secret', u'User', u'*****@*****.**')])
self.user = getUser(u'user')
self.objects = ObjectAPI(self.user)
class APIFactoryTest(FluidinfoTestCase):
resources = [('config', ConfigResource()), ('store', DatabaseResource())]
def setUp(self):
super(APIFactoryTest, self).setUp()
self.system = createSystemData()
UserAPI().create([(u'user', u'secret', u'User', u'*****@*****.**')])
self.user = getUser(u'user')
self.factory = APIFactory()
def testUsers(self):
"""L{APIFactory.users} returns a usable L{UserAPI} instance."""
self.assertIsInstance(self.factory.users(), UserAPI)
def testObjects(self):
"""L{APIFactory.objects} returns a usable L{ObjectAPI} instance."""
self.assertIsInstance(self.factory.objects(self.user), ObjectAPI)
def testNamespaces(self):
"""
L{APIFactory.namespaces} returns a usable L{NamespaceAPI} instance.
"""
self.assertIsInstance(self.factory.namespaces(self.user), NamespaceAPI)
def testTags(self):
"""L{APIFactory.tags} returns a usable L{TagAPI} instance."""
self.assertIsInstance(self.factory.tags(self.user), TagAPI)
def testTagValues(self):
"""L{APIFactory.tagValues} returns a usable L{TagValueAPI} instance."""
self.assertIsInstance(self.factory.tagValues(self.user), TagValueAPI)
def testPermissions(self):
"""
L{APIFactory.permissions} returns a usable L{PermissionAPI} instance.
"""
self.assertIsInstance(self.factory.permissions(self.user),
PermissionAPI)
def testPermissionCheckers(self):
"""
L{APIFactory.permissionCheckers} returns a usable
L{PermissionCheckerAPI} instance.
"""
self.assertIsInstance(self.factory.permissionCheckers(),
PermissionCheckerAPI)
def testRecentActivity(self):
"""
L{APIFactory.recentActivity} returns a usable L{RecentActivityAPI}
instance.
"""
self.assertIsInstance(self.factory.recentActivity(), RecentActivityAPI)
class OAuthRenewalTokenTest(OAuthAccessTokenBaseTestMixin, FluidinfoTestCase):
cls = OAuthRenewalToken
resources = [('config', ConfigResource()),
('store', DatabaseResource())]
def setUp(self):
super(OAuthRenewalTokenTest, self).setUp()
createSystemData()
secret = ''.join(sample(ALPHABET, 16))
self.config.set('oauth', 'renewal-secret', secret)
class SecureUserAPITest(UserAPITestMixin, CachingUserAPITestMixin,
FluidinfoTestCase):
resources = [('cache', CacheResource()), ('config', ConfigResource()),
('store', DatabaseResource())]
def setUp(self):
super(SecureUserAPITest, self).setUp()
self.system = createSystemData()
user = self.system.users[u'fluiddb']
self.users = SecureUserAPI(user)
class SecureUserAPIWithAnonymousRoleTest(FluidinfoTestCase):
resources = [('cache', CacheResource()), ('config', ConfigResource()),
('store', DatabaseResource())]
def setUp(self):
super(SecureUserAPIWithAnonymousRoleTest, self).setUp()
system = createSystemData()
self.user = system.users[u'anon']
self.users = SecureUserAPI(self.user)
def testCreateIsDenied(self):
"""
L{SecureUserAPI.create} raises a L{PermissionDeniedError} if it's
invoked by a L{User} with the L{Role.ANONYMOUS}.
"""
values = [(u'user', u'secret', u'User', u'*****@*****.**')]
error = self.assertRaises(PermissionDeniedError, self.users.create,
values)
self.assertEqual(self.user.username, error.username)
self.assertEqual([(u'user', Operation.CREATE_USER)],
error.pathsAndOperations)
def testDeleteIsDenied(self):
"""
L{SecureUserAPI.delete} raises a L{PermissionDeniedError} if it's
invoked by a L{User} with the L{Role.ANONYMOUS}.
"""
error = self.assertRaises(PermissionDeniedError, self.users.delete,
[u'user'])
self.assertEqual(self.user.username, error.username)
self.assertEqual([(u'user', Operation.DELETE_USER)],
error.pathsAndOperations)
def testGetIsAllowed(self):
"""
L{SecureUserAPI.get} can always be invoked by a L{User} with the
L{Role.ANONYMOUS}.
"""
UserAPI().create([(u'user', u'secret', u'User', u'*****@*****.**')])
result = self.users.get([u'user'])
self.assertIn(u'user', result)
def testSetIsDenied(self):
"""
L{SecureUserAPI.set} raises a L{PermissionDeniedError} if it's invoked
by a L{User} with the L{Role.ANONYMOUS}.
"""
values = [(u'user', u'secret', u'User', u'*****@*****.**', None)]
error = self.assertRaises(PermissionDeniedError, self.users.set,
values)
self.assertEqual(self.user.username, error.username)
self.assertEqual([(u'user', Operation.UPDATE_USER)],
error.pathsAndOperations)
class TagValueAPITest(TagValueAPITestMixin, FluidinfoTestCase):
resources = [('store', DatabaseResource())]
def setUp(self):
super(TagValueAPITest, self).setUp()
self.system = createSystemData()
UserAPI().create([(u'username', u'password', u'User',
u'*****@*****.**')])
self.user = getUser(u'username')
self.permissions = PermissionAPI(self.user)
self.tagValues = TagValueAPI(self.user)
