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 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 testGetBinaryValue(self):
"""
L{TagValueAPI.get} returns the MIME type and file contents for binary
L{TagValue}s.
"""
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
objectID = uuid4()
# NOTE: we use 'Hello \xA2' as value to test that a non utf-8 string
# will work properly.
values = {
objectID: {
u'name/tag': {
'mime-type': 'text/plain',
'contents': 'Hello \xA2'
}
}
}
self.tagValues.set(values)
result = self.tagValues.get([objectID], [u'name/tag'])
self.assertEqual(values[objectID][u'name/tag']['mime-type'],
result[objectID][u'name/tag'].value['mime-type'])
self.assertEqual(values[objectID][u'name/tag']['contents'],
result[objectID][u'name/tag'].value['contents'])
def testDeleteOnlyDirtiesRemovedObjects(self):
"""L{TagValueAPI.delete} only marks affected objects as being dirty."""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
result = self.tagValues.delete([(objectID, u'name/tag')])
self.assertEqual(0, result)
self.assertNotIn(objectID,
getDirtyObjects().values(DirtyObject.objectID))
def testDeleteOnlyDirtiesRemovedObjects(self):
"""L{TagValueAPI.delete} only marks affected objects as being dirty."""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
result = self.tagValues.delete([(objectID, u'name/tag')])
self.assertEqual(0, result)
self.assertNotIn(objectID,
getDirtyObjects().values(DirtyObject.objectID))
def testSet(self):
"""L{TagValueAPI.set} stores new L{TagValue}s."""
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
objectID = uuid4()
values = {objectID: {u'name/tag': 42}}
self.tagValues.set(values)
value = getTagValues([(objectID, tag.id)]).one()
self.assertEqual(tag.id, value.tagID)
self.assertEqual(objectID, value.objectID)
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testSetUpdates(self):
"""L{TagValueAPI.set} updates an existing value with a new one."""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
self.tagValues.set({objectID: {u'name/tag': 5}})
self.tagValues.set({objectID: {u'name/tag': None}})
value = getTagValues([(objectID, tag.id)]).one()
self.assertEqual(tag.id, value.tagID)
self.assertEqual(objectID, value.objectID)
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testDelete(self):
"""L{TagValueAPI.delete} deletes L{TagValue}s."""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
createTagValue(self.user.id, tag.id, objectID, None)
self.tagValues.delete([(objectID, u'name/tag')])
values = self.store.find(TagValue, TagValue.tagID == Tag.id,
Not(Tag.path.is_in(self.system.tags)))
self.assertEqual([], list(values))
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testDeleteReturnsRowCount(self):
"""
L{TagValueAPI.delete} returns the number of rows that were deleted.
"""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
createTagValue(self.user.id, tag.id, objectID, 42)
result = self.tagValues.delete([(objectID, u'name/tag')])
self.assertEqual(1, result)
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testDeleteReturnsRowCount(self):
"""
L{TagValueAPI.delete} returns the number of rows that were deleted.
"""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
createTagValue(self.user.id, tag.id, objectID, 42)
result = self.tagValues.delete([(objectID, u'name/tag')])
self.assertEqual(1, result)
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testDelete(self):
"""L{TagValueAPI.delete} deletes L{TagValue}s."""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
createTagValue(self.user.id, tag.id, objectID, None)
self.tagValues.delete([(objectID, u'name/tag')])
values = self.store.find(TagValue, TagValue.tagID == Tag.id,
Not(Tag.path.is_in(self.system.tags)))
self.assertEqual([], list(values))
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testSetUpdates(self):
"""L{TagValueAPI.set} updates an existing value with a new one."""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
self.tagValues.set({objectID: {u'name/tag': 5}})
self.tagValues.set({objectID: {u'name/tag': None}})
value = getTagValues([(objectID, tag.id)]).one()
self.assertEqual(tag.id, value.tagID)
self.assertEqual(objectID, value.objectID)
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testSet(self):
"""L{TagValueAPI.set} stores new L{TagValue}s."""
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
objectID = uuid4()
values = {objectID: {u'name/tag': 42}}
self.tagValues.set(values)
value = getTagValues([(objectID, tag.id)]).one()
self.assertEqual(tag.id, value.tagID)
self.assertEqual(objectID, value.objectID)
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
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())
def testMissingAboutValue(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} doesn't have a C{fluiddb/about} value.
"""
test = createNamespace(self.user.id, u'user/test', self.parent.id)
createNamespacePermission(test)
createTagValue(self.user.id, self.descriptionTag.id, test.objectID,
u'Description for test tag')
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'user/test')
self.checker.check([test])
self.assertEqual(
u"Integrity Error in namespace u'user/test': "
u'About tag is missing.\n', self.log.getvalue())
def testGetOnlyFluidDBID(self):
"""
L{TagValueAPI.get} returns object IDs for the 'fluiddb/id' tag, when
requested.
"""
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
objectID = uuid4()
values = {objectID: {u'name/tag': {'mime-type': 'text/plain',
'contents': 'Hello, world!'}}}
self.tagValues.set(values)
result = self.tagValues.get([objectID], [u'fluiddb/id'])
self.assertEqual(objectID, result[objectID][u'fluiddb/id'].value)
def testGetFluidDBID(self):
"""
L{TagValueAPI.get} returns object IDs for the 'fluiddb/id' tag, in
addition to other requests L{TagValue}s, when requested.
"""
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
objectID = uuid4()
values = {objectID: {u'name/tag': 12}}
self.tagValues.set(values)
result = self.tagValues.get([objectID], [u'fluiddb/id', u'name/tag'])
self.assertEqual(objectID, result[objectID][u'fluiddb/id'].value)
self.assertEqual(12, result[objectID][u'name/tag'].value)
def testMissingAboutValue(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} doesn't have a C{fluiddb/about} value.
"""
test = createNamespace(self.user.id, u'user/test', self.parent.id)
createNamespacePermission(test)
createTagValue(self.user.id, self.descriptionTag.id, test.objectID,
u'Description for test tag')
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'user/test')
self.checker.check([test])
self.assertEqual(u"Integrity Error in namespace u'user/test': "
u'About tag is missing.\n',
self.log.getvalue())
def testGetFluidDBID(self):
"""
L{TagValueAPI.get} returns object IDs for the 'fluiddb/id' tag, in
addition to other requests L{TagValue}s, when requested.
"""
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
objectID = uuid4()
values = {objectID: {u'name/tag': 12}}
self.tagValues.set(values)
result = self.tagValues.get([objectID], [u'fluiddb/id', u'name/tag'])
self.assertEqual(objectID, result[objectID][u'fluiddb/id'].value)
self.assertEqual(12, result[objectID][u'name/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 testMissingDescriptionTagValue(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} doesn't have C{fluiddb/namespaces/description} value.
"""
test = createNamespace(self.user.id, u'user/test', self.parent.id)
createNamespacePermission(test)
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'user/test')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the namespace %s' % test.path)
self.checker.check([test])
self.assertEqual(
"Integrity Error in namespace u'user/test': "
'Description tag is missing.\n', self.log.getvalue())
def testMissingDescriptionTagValue(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} doesn't have C{fluiddb/namespaces/description} value.
"""
test = createNamespace(self.user.id, u'user/test', self.parent.id)
createNamespacePermission(test)
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'user/test')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the namespace %s' % test.path)
self.checker.check([test])
self.assertEqual("Integrity Error in namespace u'user/test': "
'Description tag is missing.\n',
self.log.getvalue())
def _createNamespacePermissions(self, namespace):
"""Create L{NamespacePermission}s."""
permission = createNamespacePermission(namespace)
permission.set(Operation.CREATE_NAMESPACE, Policy.CLOSED, [])
permission.set(Operation.UPDATE_NAMESPACE, Policy.CLOSED, [])
permission.set(Operation.DELETE_NAMESPACE, Policy.CLOSED, [])
permission.set(Operation.LIST_NAMESPACE, Policy.CLOSED, [])
permission.set(Operation.CONTROL_NAMESPACE, Policy.CLOSED, [])
def _createNamespacePermissions(self, namespace):
"""Create L{NamespacePermission}s."""
permission = createNamespacePermission(namespace)
permission.set(Operation.CREATE_NAMESPACE, Policy.CLOSED, [])
permission.set(Operation.UPDATE_NAMESPACE, Policy.CLOSED, [])
permission.set(Operation.DELETE_NAMESPACE, Policy.CLOSED, [])
permission.set(Operation.LIST_NAMESPACE, Policy.CLOSED, [])
permission.set(Operation.CONTROL_NAMESPACE, Policy.CLOSED, [])
def testWrongPathTagValue(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} has a wrong C{fluiddb/namespaces/path} value.
"""
test = createNamespace(self.user.id, u'user/test', self.parent.id)
createNamespacePermission(test)
createTagValue(self.user.id, self.descriptionTag.id, test.objectID,
u'Description for test tag')
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'wrong/path')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the namespace %s' % test.path)
self.checker.check([test])
self.assertEqual("Integrity Error in namespace u'user/test': "
'Path tag is incorrect.\n',
self.log.getvalue())
def testWrongPathTagValue(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} has a wrong C{fluiddb/namespaces/path} value.
"""
test = createNamespace(self.user.id, u'user/test', self.parent.id)
createNamespacePermission(test)
createTagValue(self.user.id, self.descriptionTag.id, test.objectID,
u'Description for test tag')
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'wrong/path')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the namespace %s' % test.path)
self.checker.check([test])
self.assertEqual(
"Integrity Error in namespace u'user/test': "
'Path tag is incorrect.\n', self.log.getvalue())
def testInvalidPaths(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} has a wrong path.
"""
test = Namespace(self.user, u'user/$bad!', u'$bad!', self.parent.id)
createNamespacePermission(test)
createTagValue(self.user.id, self.descriptionTag.id, test.objectID,
u'Description for $bad! tag')
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'user/$bad!')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the namespace %s' % test.path)
self.checker.check([test])
self.assertEqual("Integrity Error in namespace u'user/$bad!': "
'Invalid path.\n',
self.log.getvalue())
def testInvalidPaths(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} has a wrong path.
"""
test = Namespace(self.user, u'user/$bad!', u'$bad!', self.parent.id)
createNamespacePermission(test)
createTagValue(self.user.id, self.descriptionTag.id, test.objectID,
u'Description for $bad! tag')
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'user/$bad!')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the namespace %s' % test.path)
self.checker.check([test])
self.assertEqual(
"Integrity Error in namespace u'user/$bad!': "
'Invalid path.\n', self.log.getvalue())
def testGetWithInvalidOperation(self):
"""
L{NamespacePermission.get} raises a C{RuntimeError} if an invalid
L{Operation} is provided.
"""
user = createUser(u'name', u'password', u'Name', u'*****@*****.**')
namespace = createNamespace(user, u'name')
permission = createNamespacePermission(namespace)
self.assertRaises(RuntimeError, permission.get,
Operation.WRITE_TAG_VALUE)
def testAllowWithInvalidOperation(self):
"""
L{NamespacePermission.allow} raises a C{RuntimeError} if the request
L{Operation} is not a namespace operation.
"""
user = createUser(u'name', u'password', u'Name', u'*****@*****.**')
namespace = createNamespace(user, u'name')
permission = createNamespacePermission(namespace)
self.assertRaises(RuntimeError, permission.allow, user.id,
Operation.WRITE_TAG_VALUE)
def testNotAssociatedParent(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} doesn't have an associated parent when it's path suggests
one.
"""
test = createNamespace(self.user.id, u'user/test', None)
createNamespacePermission(test)
createTagValue(self.user.id, self.descriptionTag.id, test.objectID,
u'Description for test tag')
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'user/test')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the namespace %s' % test.path)
self.checker.check([test])
self.assertEqual(
"Integrity Error in namespace u'user/test': "
'Parent ID is not specified.\n', self.log.getvalue())
def testDeleteRemovesTagValues(self):
"""
L{TagValueAPI.delete} removes L{TagValue}s associated with the deleted
L{Tag}s.
"""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag1 = createTag(self.user, namespace, u'tag1')
tag2 = createTag(self.user, namespace, u'tag2')
createTagPermission(tag1)
createTagPermission(tag2)
value = createTagValue(self.user.id, tag1.id, objectID, 42)
createTagValue(self.user.id, tag2.id, objectID, 17)
self.tagValues.delete([(objectID, u'name/tag2')])
values = self.store.find(TagValue, TagValue.tagID == Tag.id,
Not(Tag.path.is_in(self.system.tags)))
self.assertEqual([value], list(values))
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testDeleteOnlyConsidersSpecifiedObjectIDs(self):
"""
L{TagValueAPI.delete} only removes the values for the specified object
IDs.
"""
objectID1 = uuid4()
objectID2 = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
createTagValue(self.user.id, tag.id, objectID1, 42)
value = createTagValue(self.user.id, tag.id, objectID2, 17)
self.tagValues.delete([(objectID1, u'name/tag')])
values = self.store.find(TagValue, TagValue.tagID == Tag.id,
Not(Tag.path.is_in(self.system.tags)))
self.assertEqual([value], list(values))
self.assertIn(objectID1,
getDirtyObjects().values(DirtyObject.objectID))
def testDeleteOnlyConsidersSpecifiedObjectIDs(self):
"""
L{TagValueAPI.delete} only removes the values for the specified object
IDs.
"""
objectID1 = uuid4()
objectID2 = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
createTagValue(self.user.id, tag.id, objectID1, 42)
value = createTagValue(self.user.id, tag.id, objectID2, 17)
self.tagValues.delete([(objectID1, u'name/tag')])
values = self.store.find(TagValue, TagValue.tagID == Tag.id,
Not(Tag.path.is_in(self.system.tags)))
self.assertEqual([value], list(values))
self.assertIn(objectID1,
getDirtyObjects().values(DirtyObject.objectID))
def testNotAssociatedParent(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} doesn't have an associated parent when it's path suggests
one.
"""
test = createNamespace(self.user.id, u'user/test', None)
createNamespacePermission(test)
createTagValue(self.user.id, self.descriptionTag.id, test.objectID,
u'Description for test tag')
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'user/test')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the namespace %s' % test.path)
self.checker.check([test])
self.assertEqual("Integrity Error in namespace u'user/test': "
'Parent ID is not specified.\n',
self.log.getvalue())
def testWrongParent(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} has a wrong associated parent.
"""
parent = createNamespace(self.user.id, u'parent', None)
test = createNamespace(self.user.id, u'user/test', parent.id)
createNamespacePermission(test)
createTagValue(self.user.id, self.descriptionTag.id, test.objectID,
u'Description for test tag')
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'user/test')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the namespace %s' % test.path)
self.checker.check([test])
self.assertEqual("Integrity Error in namespace u'user/test': "
'Assigned parent is incorrect.\n',
self.log.getvalue())
def testDeleteRemovesTagValues(self):
"""
L{TagValueAPI.delete} removes L{TagValue}s associated with the deleted
L{Tag}s.
"""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag1 = createTag(self.user, namespace, u'tag1')
tag2 = createTag(self.user, namespace, u'tag2')
createTagPermission(tag1)
createTagPermission(tag2)
value = createTagValue(self.user.id, tag1.id, objectID, 42)
createTagValue(self.user.id, tag2.id, objectID, 17)
self.tagValues.delete([(objectID, u'name/tag2')])
values = self.store.find(TagValue, TagValue.tagID == Tag.id,
Not(Tag.path.is_in(self.system.tags)))
self.assertEqual([value], list(values))
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testWrongParent(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if the given
L{Namespace} has a wrong associated parent.
"""
parent = createNamespace(self.user.id, u'parent', None)
test = createNamespace(self.user.id, u'user/test', parent.id)
createNamespacePermission(test)
createTagValue(self.user.id, self.descriptionTag.id, test.objectID,
u'Description for test tag')
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'user/test')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the namespace %s' % test.path)
self.checker.check([test])
self.assertEqual(
"Integrity Error in namespace u'user/test': "
'Assigned parent is incorrect.\n', self.log.getvalue())
def testGetBinaryValue(self):
"""
L{TagValueAPI.get} returns the MIME type and file contents for binary
L{TagValue}s.
"""
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
objectID = uuid4()
# NOTE: we use 'Hello \xA2' as value to test that a non utf-8 string
# will work properly.
values = {objectID: {u'name/tag': {'mime-type': 'text/plain',
'contents': 'Hello \xA2'}}}
self.tagValues.set(values)
result = self.tagValues.get([objectID], [u'name/tag'])
self.assertEqual(values[objectID][u'name/tag']['mime-type'],
result[objectID][u'name/tag'].value['mime-type'])
self.assertEqual(values[objectID][u'name/tag']['contents'],
result[objectID][u'name/tag'].value['contents'])
def testGet(self):
"""
L{NamespacePermission.get} returns a C{(Policy, exceptions)} 2-tuple
for the specified L{Operation}.
"""
user = createUser(u'name', u'password', u'Name', u'*****@*****.**')
namespace = createNamespace(user, u'name')
permission = createNamespacePermission(namespace)
permission.set(Operation.CREATE_NAMESPACE, Policy.OPEN, [user.id])
self.assertEqual((Policy.OPEN, [user.id]),
permission.get(Operation.CREATE_NAMESPACE))
def testGetFilteredByObjectIDsAndPath(self):
"""
When both object IDs and tag paths are provided, L{TagValueAPI.get}
returns only those L{Tag} values that meet both criteria.
"""
objectID1 = uuid4()
objectID2 = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag1 = createTag(self.user, namespace, u'tag1')
tag2 = createTag(self.user, namespace, u'tag2')
createTagPermission(tag1)
createTagPermission(tag2)
createTagValue(self.user.id, tag1.id, objectID1, 42)
createTagValue(self.user.id, tag1.id, objectID2, 67)
createTagValue(self.user.id, tag2.id, objectID1, 17)
createTagValue(self.user.id, tag2.id, objectID2, 13)
result = self.tagValues.get(objectIDs=[objectID1],
paths=[u'name/tag1'])
self.assertEqual(42, result[objectID1][u'name/tag1'].value)
def testAllowWithOpenPolicyAndUserInExceptions(self):
"""
L{NamespacePermission.allow} denies access if the policy is
L{Policy.OPEN} and the L{User} is in the exceptions list.
"""
user = createUser(u'name', u'password', u'Name', u'*****@*****.**')
namespace = createNamespace(user, u'name')
permission = createNamespacePermission(namespace)
permission.createPolicy = Policy.OPEN
permission.createExceptions = [user.id]
self.assertFalse(permission.allow(Operation.CREATE_NAMESPACE, user.id))
def testGetFilteredByObjectIDsAndPath(self):
"""
When both object IDs and tag paths are provided, L{TagValueAPI.get}
returns only those L{Tag} values that meet both criteria.
"""
objectID1 = uuid4()
objectID2 = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag1 = createTag(self.user, namespace, u'tag1')
tag2 = createTag(self.user, namespace, u'tag2')
createTagPermission(tag1)
createTagPermission(tag2)
createTagValue(self.user.id, tag1.id, objectID1, 42)
createTagValue(self.user.id, tag1.id, objectID2, 67)
createTagValue(self.user.id, tag2.id, objectID1, 17)
createTagValue(self.user.id, tag2.id, objectID2, 13)
result = self.tagValues.get(objectIDs=[objectID1],
paths=[u'name/tag1'])
self.assertEqual(42, result[objectID1][u'name/tag1'].value)
def testSetBinaryValue(self):
"""
L{TagValueAPI.set} can store binary L{TagValue}s. The contents
included in the dict representing the value are written to a file and
added to the L{FileStore}.
"""
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
objectID = uuid4()
self.tagValues.set(
{objectID: {u'name/tag': {'mime-type': 'text/plain',
'contents': 'Hello, world!'}}})
value = getTagValues([(objectID, tag.id)]).one()
self.assertEqual(tag.id, value.tagID)
self.assertEqual(objectID, value.objectID)
self.assertEqual({'mime-type': 'text/plain',
'size': 13},
value.value)
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testCreateNamespacePermissionAddsToStore(self):
"""
L{createNamespacePermission} automatically adds the new
L{NamespacePermission} to the database.
"""
user = createUser(u'name', u'password', u'Name', u'*****@*****.**')
namespace = createNamespace(user, u'name')
permission = createNamespacePermission(namespace)
result = self.store.find(
NamespacePermission,
NamespacePermission.namespaceID == namespace.id)
self.assertIdentical(permission, result.one())
def testDeleteRemovesTagValuesWhenPassedAGenerator(self):
"""
L{TagValueAPI.delete} removes L{TagValue}s associated with the
deleted L{Tag}s when it is passed a generator (as opposed to a
C{list}).
"""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag1 = createTag(self.user, namespace, u'tag1')
tag2 = createTag(self.user, namespace, u'tag2')
createTagPermission(tag1)
createTagPermission(tag2)
value = createTagValue(self.user.id, tag1.id, objectID, 42)
createTagValue(self.user.id, tag2.id, objectID, 17)
values = ((objectID, name) for name in [u'name/tag2'])
self.tagValues.delete(values)
values = self.store.find(TagValue, TagValue.tagID == Tag.id,
Not(Tag.path.is_in(self.system.tags)))
self.assertEqual([value], list(values))
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testGetOnlyFluidDBID(self):
"""
L{TagValueAPI.get} returns object IDs for the 'fluiddb/id' tag, when
requested.
"""
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
objectID = uuid4()
values = {
objectID: {
u'name/tag': {
'mime-type': 'text/plain',
'contents': 'Hello, world!'
}
}
}
self.tagValues.set(values)
result = self.tagValues.get([objectID], [u'fluiddb/id'])
self.assertEqual(objectID, result[objectID][u'fluiddb/id'].value)
def testDeleteRemovesTagValuesWhenPassedAGenerator(self):
"""
L{TagValueAPI.delete} removes L{TagValue}s associated with the
deleted L{Tag}s when it is passed a generator (as opposed to a
C{list}).
"""
objectID = uuid4()
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag1 = createTag(self.user, namespace, u'tag1')
tag2 = createTag(self.user, namespace, u'tag2')
createTagPermission(tag1)
createTagPermission(tag2)
value = createTagValue(self.user.id, tag1.id, objectID, 42)
createTagValue(self.user.id, tag2.id, objectID, 17)
values = ((objectID, name) for name in [u'name/tag2'])
self.tagValues.delete(values)
values = self.store.find(TagValue, TagValue.tagID == Tag.id,
Not(Tag.path.is_in(self.system.tags)))
self.assertEqual([value], list(values))
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testSet(self):
"""
L{NamespacePermission.set} updates the L{Policy} and exceptions list
for an L{Operation}.
"""
user = createUser(u'name', u'password', u'Name', u'*****@*****.**')
namespace = createNamespace(user, u'name')
permission = createNamespacePermission(namespace)
self.assertEqual(Policy.CLOSED, permission.createPolicy)
self.assertEqual([user.id], permission.createExceptions)
permission.set(Operation.CREATE_NAMESPACE, Policy.OPEN, [])
self.assertEqual(Policy.OPEN, permission.createPolicy)
self.assertEqual([], permission.createExceptions)
def testSetBinaryValue(self):
"""
L{TagValueAPI.set} can store binary L{TagValue}s. The contents
included in the dict representing the value are written to a file and
added to the L{FileStore}.
"""
namespace = createNamespace(self.user, u'name')
createNamespacePermission(namespace)
tag = createTag(self.user, namespace, u'tag')
createTagPermission(tag)
objectID = uuid4()
self.tagValues.set({
objectID: {
u'name/tag': {
'mime-type': 'text/plain',
'contents': 'Hello, world!'
}
}
})
value = getTagValues([(objectID, tag.id)]).one()
self.assertEqual(tag.id, value.tagID)
self.assertEqual(objectID, value.objectID)
self.assertEqual({'mime-type': 'text/plain', 'size': 13}, value.value)
self.assertIn(objectID, getDirtyObjects().values(DirtyObject.objectID))
def testSuperuserInPermissionExceptions(self):
"""
L{NamespaceIntegrityChecker.check} logs an error if a superuser is in a
permission exceptions list.
"""
test = createNamespace(self.user.id, u'user/test', self.parent.id)
permission = createNamespacePermission(test)
permission.createExceptions = [self.user.id, self.superuser.id]
createTagValue(self.user.id, self.descriptionTag.id, test.objectID,
u'Description for test tag')
createTagValue(self.user.id, self.pathTag.id, test.objectID,
u'user/test')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the namespace %s' % test.path)
self.checker.check([test])
self.assertEqual("Integrity Error in namespace u'user/test': "
'A superuser is in the exceptions list for '
'CREATE_NAMESPACE permission.\n',
self.log.getvalue())
def testReadonlyWithTupleResult(self):
"""L{readonly} correctly handles tuple results."""
user = createUser(u'username', u'secret', u'name', u'*****@*****.**')
namespace = createNamespace(user, u'username')
permission = createNamespacePermission(namespace)
result = getNamespacePermissions([u'username'])
readonlyNamespace, readonlyPermission = readonly(result).one()
self.assertNotIdentical(namespace, readonlyNamespace)
self.assertEqual(namespace.id, readonlyNamespace.id)
self.assertEqual(namespace.objectID, readonlyNamespace.objectID)
self.assertEqual(namespace.parentID, readonlyNamespace.parentID)
self.assertEqual(namespace.creatorID, readonlyNamespace.creatorID)
self.assertEqual(namespace.path, readonlyNamespace.path)
self.assertEqual(namespace.name, readonlyNamespace.name)
self.assertEqual(namespace.creationTime,
readonlyNamespace.creationTime)
self.assertNotIdentical(permission, readonlyPermission)
self.assertEqual(permission.createPolicy,
readonlyPermission.createPolicy)
self.assertEqual(permission.createExceptions,
readonlyPermission.createExceptions)
self.assertEqual(permission.updatePolicy,
readonlyPermission.updatePolicy)
self.assertEqual(permission.updateExceptions,
readonlyPermission.updateExceptions)
self.assertEqual(permission.deletePolicy,
readonlyPermission.deletePolicy)
self.assertEqual(permission.deleteExceptions,
readonlyPermission.deleteExceptions)
self.assertEqual(permission.listPolicy,
readonlyPermission.listPolicy)
self.assertEqual(permission.listExceptions,
readonlyPermission.listExceptions)
self.assertEqual(permission.controlPolicy,
readonlyPermission.controlPolicy)
self.assertEqual(permission.controlExceptions,
readonlyPermission.controlExceptions)
