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)