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 testGetWithoutObjectIDs(self):
"""
L{TagValueAPI.get} raises L{FeatureError} if no object IDs are given.
"""
tag = createTag(self.user, self.user.namespace, u'tag')
createTagPermission(tag)
self.assertRaises(FeatureError, self.tagValues.get, [],
[u'username/tag'])
def testGetWithoutObjectIDs(self):
"""
L{TagValueAPI.get} raises L{FeatureError} if no object IDs are given.
"""
tag = createTag(self.user, self.user.namespace, u'tag')
createTagPermission(tag)
self.assertRaises(FeatureError, self.tagValues.get, [],
[u'username/tag'])
def testSet(self):
"""L{TagAPI.set} updates the description for the specified L{Tag}s."""
descriptionTag = self.system.tags[u'fluiddb/tags/description']
tag = createTag(self.user, self.user.namespace, u'tag')
createTagPermission(tag)
self.tags.set({u'username/tag': u'A fancy new description.'})
result = getTagValues([(tag.objectID, descriptionTag.id)])
description = result.one()
self.assertEqual(u'A fancy new description.', description.value)
def testGet(self):
"""
L{PermissionAPI.get} returns a C{dict} of permissions for the
specified path and L{Operation}.
"""
tag = createTag(self.user, self.user.namespace, u'tag')
createTagPermission(tag)
action = (u'username/tag', Operation.UPDATE_TAG)
permissions = self.permissions.get([action])
self.assertEqual({action: (Policy.CLOSED, [u'username'])}, permissions)
def testGetFilteredByUnknownObjectIDs(self):
"""
L{TagValueAPI.get} doesn't return any L{Tag} values if none of the
requested object IDs exist.
"""
tag = createTag(self.user, self.user.namespace, u'tag')
createTagPermission(tag)
createTagValue(self.user.id, tag.id, uuid4(), 42)
self.assertEqual({}, self.tagValues.get(objectIDs=[uuid4()],
paths=[u'username/tag']))
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 testGetFilteredByUnknownObjectIDs(self):
"""
L{TagValueAPI.get} doesn't return any L{Tag} values if none of the
requested object IDs exist.
"""
tag = createTag(self.user, self.user.namespace, u'tag')
createTagPermission(tag)
createTagValue(self.user.id, tag.id, uuid4(), 42)
self.assertEqual({},
self.tagValues.get(objectIDs=[uuid4()],
paths=[u'username/tag']))
def testSetWithUnknownUser(self):
"""
L{PermissionAPI.set} raises L{UknownUserError} if a username
specified in the C{exceptions} list does not exist.
"""
tag = createTag(self.user, self.user.namespace, u'tag')
createTagPermission(tag)
values = [(u'username/tag', Operation.DELETE_TAG,
Policy.OPEN, [u'unknown'])]
error = self.assertRaises(UnknownUserError, self.permissions.set,
values)
self.assertEqual([u'unknown'], error.usernames)
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 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 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 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 testGetTagsForObjects(self):
"""
L{ObjectAPI.getTagsForObjects} returns a C{list} of L{Tag.path}s that
are associated with the given objects.
"""
tag = createTag(self.user, self.user.namespace, u'tag')
createTagPermission(tag)
objectID1 = uuid4()
objectID2 = uuid4()
createTagValue(self.user.id, tag.id, objectID1, u'value1')
createTagValue(self.user.id, tag.id, objectID2, u'value2')
self.assertEqual(
[u'user/tag'],
self.objects.getTagsForObjects([objectID1, objectID2]))
def testGetTagsForObjects(self):
"""
L{ObjectAPI.getTagsForObjects} returns a C{list} of L{Tag.path}s that
are associated with the given objects.
"""
tag = createTag(self.user, self.user.namespace, u'tag')
createTagPermission(tag)
objectID1 = uuid4()
objectID2 = uuid4()
createTagValue(self.user.id, tag.id, objectID1, u'value1')
createTagValue(self.user.id, tag.id, objectID2, u'value2')
self.assertEqual([u'user/tag'],
self.objects.getTagsForObjects([objectID1,
objectID2]))
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 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{TagIntegrityChecker.check} logs an error if the given L{Tag} doesn't
have a C{fluiddb/about} value.
"""
test = createTag(self.user, self.parent, u'test')
createTagPermission(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("Integrity Error in tag u'user/test': "
'About tag is missing.\n',
self.log.getvalue())
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 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 testMissingDescriptionTagValue(self):
"""
L{TagIntegrityChecker.check} logs an error if the given L{Tag} doesn't
have C{fluiddb/tags/description} value.
"""
test = createTag(self.user, self.parent, u'test')
createTagPermission(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 attribute %s' % test.path)
self.checker.check([test])
self.assertEqual("Integrity Error in tag u'user/test': "
'Description tag is missing.\n',
self.log.getvalue())
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 testMissingAboutValue(self):
"""
L{TagIntegrityChecker.check} logs an error if the given L{Tag} doesn't
have a C{fluiddb/about} value.
"""
test = createTag(self.user, self.parent, u'test')
createTagPermission(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(
"Integrity Error in tag u'user/test': "
'About tag is missing.\n', self.log.getvalue())
def testMissingDescriptionTagValue(self):
"""
L{TagIntegrityChecker.check} logs an error if the given L{Tag} doesn't
have C{fluiddb/tags/description} value.
"""
test = createTag(self.user, self.parent, u'test')
createTagPermission(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 attribute %s' % test.path)
self.checker.check([test])
self.assertEqual(
"Integrity Error in tag u'user/test': "
'Description tag is missing.\n', self.log.getvalue())
def testGetTagsByObjects(self):
"""
L{ObjectAPI.getTagsByObjects} returns a C{dict} of L{Tag.path}s that
are associated with the given objects.
"""
tag1 = createTag(self.user, self.user.namespace, u'tag1')
tag2 = createTag(self.user, self.user.namespace, u'tag2')
createTagPermission(tag1)
createTagPermission(tag2)
objectID = uuid4()
createTagValue(self.user.id, tag1.id, objectID, u'value1')
createTagValue(self.user.id, tag2.id, objectID, u'value2')
tagPaths = self.objects.getTagsByObjects([objectID])
expected = {objectID: [u'user/tag1', u'user/tag2']}
tagPaths[objectID] = sorted(tagPaths[objectID])
self.assertEqual(expected, tagPaths)
def _createPermissions(self, tags):
"""Create L{TagPermission}s for new L{Tag}s.
L{Tag}s inherit permissions from their parent tag, if one
is available.
@param tags: A sequence of new L{Tag}s to create
L{TagPermission}s for.
"""
# Preload parent Namespace and NamespacePermission's into Storm's
# cache. Simply creating the objects will be enough to get them into
# the cache. If there are many objects we need to be careful about
# overloading the cache, but that isn't an issue here.
parentPaths = [getParentPath(tag.path) for tag in tags]
list(getNamespacePermissions(parentPaths))
for tag in tags:
createTagPermission(tag)
def testGetTagsByObjects(self):
"""
L{ObjectAPI.getTagsByObjects} returns a C{dict} of L{Tag.path}s that
are associated with the given objects.
"""
tag1 = createTag(self.user, self.user.namespace, u'tag1')
tag2 = createTag(self.user, self.user.namespace, u'tag2')
createTagPermission(tag1)
createTagPermission(tag2)
objectID = uuid4()
createTagValue(self.user.id, tag1.id, objectID, u'value1')
createTagValue(self.user.id, tag2.id, objectID, u'value2')
tagPaths = self.objects.getTagsByObjects([objectID])
expected = {objectID: [u'user/tag1', u'user/tag2']}
tagPaths[objectID] = sorted(tagPaths[objectID])
self.assertEqual(expected, tagPaths)
def testInvalidPaths(self):
"""
L{TagIntegrityChecker.check} logs an error if the given L{Tag} has a
wrong path.
"""
test = Tag(self.user, self.parent, u'user/$bad!', u'$bad!')
createTagPermission(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 attribute %s' % test.path)
self.checker.check([test])
self.assertEqual(
"Integrity Error in tag u'user/$bad!': "
'Invalid path.\n', self.log.getvalue())
def testGetObjectWithAboutValueDoesNotExist(self):
"""
L{FacadeObjectAPI.getObject} returns a L{TObjectInfo} with the
L{Tag.path}s for which the L{User} has L{Operation.READ_TAG_VALUE},
and the L{AboutTagValue.value} if it has one and C{showAbout} is
C{True}.
"""
objectID = uuid4()
tag = createTag(self.user, self.user.namespace, u'foo')
createTagPermission(tag)
createTagValue(self.user.id, tag.id, objectID, u'bar')
session = AuthenticatedSession(self.user.username, uuid4())
self.store.commit()
with login(self.user.username, uuid4(), self.transact) as session:
objectInfo = yield self.facade.getObject(session, str(objectID),
showAbout=True)
self.assertEqual([u'username/foo'], objectInfo.tagPaths)
self.assertIdentical(None, objectInfo.about)
def testWrongParent(self):
"""
L{TagIntegrityChecker.check} logs an error if the given L{Tag} has a
wrong associated parent.
"""
test = Tag(self.user, self.parent, u'wrong/test', u'test')
createTagPermission(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/test')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the attribute %s' % test.path)
self.checker.check([test])
self.assertEqual(
"Integrity Error in tag u'wrong/test': "
'Assigned parent is incorrect.\n', self.log.getvalue())
def testInvalidPaths(self):
"""
L{TagIntegrityChecker.check} logs an error if the given L{Tag} has a
wrong path.
"""
test = Tag(self.user, self.parent, u'user/$bad!', u'$bad!')
createTagPermission(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 attribute %s' % test.path)
self.checker.check([test])
self.assertEqual("Integrity Error in tag u'user/$bad!': "
'Invalid path.\n',
self.log.getvalue())
def testWrongParent(self):
"""
L{TagIntegrityChecker.check} logs an error if the given L{Tag} has a
wrong associated parent.
"""
test = Tag(self.user, self.parent, u'wrong/test', u'test')
createTagPermission(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/test')
createTagValue(self.user.id, self.aboutTag.id, test.objectID,
u'Object for the attribute %s' % test.path)
self.checker.check([test])
self.assertEqual("Integrity Error in tag u'wrong/test': "
'Assigned parent is incorrect.\n',
self.log.getvalue())
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 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 _createTagPermissions(self, tag):
"""Create L{TagPermission}s."""
permission = createTagPermission(tag)
permission.set(Operation.UPDATE_TAG, Policy.CLOSED, [])
permission.set(Operation.DELETE_TAG, Policy.CLOSED, [])
permission.set(Operation.CONTROL_TAG, Policy.CLOSED, [])
permission.set(Operation.WRITE_TAG_VALUE, Policy.CLOSED, [])
permission.set(Operation.READ_TAG_VALUE, Policy.OPEN, [])
permission.set(Operation.DELETE_TAG_VALUE, Policy.CLOSED, [])
permission.set(Operation.CONTROL_TAG_VALUE, Policy.CLOSED, [])
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 testGetObjectWithAboutValueDoesNotExist(self):
"""
L{FacadeObjectAPI.getObject} returns a L{TObjectInfo} with the
L{Tag.path}s for which the L{User} has L{Operation.READ_TAG_VALUE},
and the L{AboutTagValue.value} if it has one and C{showAbout} is
C{True}.
"""
objectID = uuid4()
tag = createTag(self.user, self.user.namespace, u'foo')
createTagPermission(tag)
createTagValue(self.user.id, tag.id, objectID, u'bar')
session = AuthenticatedSession(self.user.username, uuid4())
self.store.commit()
with login(self.user.username, uuid4(), self.transact) as session:
objectInfo = yield self.facade.getObject(session,
str(objectID),
showAbout=True)
self.assertEqual([u'username/foo'], objectInfo.tagPaths)
self.assertIdentical(None, objectInfo.about)
def _createTagPermissions(self, tag):
"""Create L{TagPermission}s."""
permission = createTagPermission(tag)
permission.set(Operation.UPDATE_TAG, Policy.CLOSED, [])
permission.set(Operation.DELETE_TAG, Policy.CLOSED, [])
permission.set(Operation.CONTROL_TAG, Policy.CLOSED, [])
permission.set(Operation.WRITE_TAG_VALUE, Policy.CLOSED, [])
permission.set(Operation.READ_TAG_VALUE, Policy.OPEN, [])
permission.set(Operation.DELETE_TAG_VALUE, Policy.CLOSED, [])
permission.set(Operation.CONTROL_TAG_VALUE, Policy.CLOSED, [])
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 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 testAllowWithInvalidOperation(self):
"""
L{TagPermission.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')
tag = createTag(user, namespace, u'tag')
permission = createTagPermission(tag)
self.assertRaises(RuntimeError, permission.allow, user.id,
Operation.CREATE_NAMESPACE)
def testCreateTagPermissionAddsToStore(self):
"""
L{createTagPermission} automatically adds the new L{TagPermission} to
the database.
"""
user = createUser(u'name', u'password', u'Name', u'*****@*****.**')
namespace = createNamespace(user, u'name')
tag = createTag(user, namespace, u'tag')
permission = createTagPermission(tag)
result = self.store.find(TagPermission, TagPermission.tagID == tag.id)
self.assertIdentical(permission, result.one())
def testSetWithInvalidOperation(self):
"""
L{TagPermission.set} 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')
tag = createTag(user, namespace, u'tag')
permission = createTagPermission(tag)
self.assertRaises(RuntimeError, permission.set,
Operation.CREATE_NAMESPACE, Policy.OPEN, [])
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 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 testSuperuserInPermissionExceptions(self):
"""
L{TagIntegrityChecker.check} logs an error if a superuser is in a
permission exceptions list.
"""
test = createTag(self.user, self.parent, u'test')
permission = createTagPermission(test)
permission.updateExceptions = [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 attribute %s' % test.path)
self.checker.check([test])
self.assertEqual("Integrity Error in tag u'user/test': "
'A superuser is in the exceptions list for '
'UPDATE_TAG permission.\n',
self.log.getvalue())
