def testGet(self):
"""L{TagAPI.get} returns L{Tag}s that match the specified paths."""
createTag(self.user, self.user.namespace, u'ignored')
tag = createTag(self.user, self.user.namespace, u'tag')
self.assertEqual({u'username/tag': {
'id': tag.objectID
}}, self.tags.get([u'username/tag']))
def testCreateWithExistingTagPath(self):
"""
L{TagAPI.create} raises a L{DuplicatePathError} exception if an
attempt to create a L{Tag} with the same path an existing L{Tag} is
made.
"""
createTag(self.user, self.user.namespace, u'name')
self.assertRaises(DuplicatePathError, self.tags.create,
[(u'username/name', u'Already used tag path.')])
def testGetWithTags(self):
"""
L{NamespaceAPI.get} can optionally include the names of child L{Tag}s
in the result.
"""
createTag(self.user, self.user.namespace, u'tag')
self.assertEqual({'username': {'id': self.user.namespace.objectID,
'tagNames': [u'tag']}},
self.namespaces.get([u'username'], withTags=True))
def testDeleteWithChildTag(self):
"""
L{NamespaceAPI.delete} raises a L{NotEmptyError} if a child L{Tag}
exists.
"""
self.namespaces.create([(u'username/child', u'A description')])
namespace = getNamespaces(paths=[u'username/child']).one()
createTag(self.user, namespace, u'tag')
self.assertRaises(NotEmptyError,
self.namespaces.delete, [u'username/child'])
def testDeleteWithChildTag(self):
"""
L{NamespaceAPI.delete} raises a L{NotEmptyError} if a child L{Tag}
exists.
"""
self.namespaces.create([(u'username/child', u'A description')])
namespace = getNamespaces(paths=[u'username/child']).one()
createTag(self.user, namespace, u'tag')
self.assertRaises(NotEmptyError, self.namespaces.delete,
[u'username/child'])
def testDeleteIsDenied(self):
"""
L{SecureTagAPI.delete} raises a L{PermissionDeniedError} if its
invoked by a L{User} with the L{Role.ANONYMOUS}.
"""
createTag(self.user, self.user.namespace, u'path')
error = self.assertRaises(PermissionDeniedError, self.tags.delete,
[u'user/path'])
self.assertEqual(self.anon.username, error.username)
self.assertEqual([('user/path', Operation.DELETE_TAG)],
error.pathsAndOperations)
def testSetIsDenied(self):
"""
L{SecureTagAPI.set} raises a L{PermissionDeniedError} if its invoked
by a L{User} with the L{Role.ANONYMOUS}.
"""
createTag(self.user, self.user.namespace, u'path')
error = self.assertRaises(PermissionDeniedError, self.tags.set,
{u'user/path': 'A path tag'})
self.assertEqual(self.anon.username, error.username)
self.assertEqual([('user/path', Operation.UPDATE_TAG)],
error.pathsAndOperations)
def testDeleteIsDenied(self):
"""
L{SecureTagAPI.delete} raises a L{PermissionDeniedError} if its
invoked by a L{User} with the L{Role.ANONYMOUS}.
"""
createTag(self.user, self.user.namespace, u'path')
error = self.assertRaises(PermissionDeniedError, self.tags.delete,
[u'user/path'])
self.assertEqual(self.anon.username, error.username)
self.assertEqual([('user/path', Operation.DELETE_TAG)],
error.pathsAndOperations)
def testSetIsDenied(self):
"""
L{SecureTagAPI.set} raises a L{PermissionDeniedError} if its invoked
by a L{User} with the L{Role.ANONYMOUS}.
"""
createTag(self.user, self.user.namespace, u'path')
error = self.assertRaises(PermissionDeniedError, self.tags.set,
{u'user/path': 'A path tag'})
self.assertEqual(self.anon.username, error.username)
self.assertEqual([('user/path', Operation.UPDATE_TAG)],
error.pathsAndOperations)
def testGetTagPathsAndObjectIDsWithUnknownObjectID(self):
"""
L{getTagPathsAndObjectIDs} doesn't return any results if unknown
object IDs 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')
createTag(user, user.namespace, u'name2')
createTagValue(user.id, tag.id, uuid4(), 42)
self.assertEqual([], list(getTagPathsAndObjectIDs([uuid4()])))
def testGetTagsWithPaths(self):
"""
When L{Tag.path}s are provided L{getTags} returns matching L{Tag}s.
"""
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag = createTag(user, user.namespace, u'name1')
createTag(user, user.namespace, u'name2')
result = getTags(paths=[u'username/name1'])
self.assertIdentical(tag, result.one())
def testGetNamespaceWithTags(self):
"""
L{Facade.getNamespace} includes child L{Tag.name}s, if they were
requested.
"""
createTag(self.user, self.user.namespace, u'tag')
self.store.commit()
with login(u'username', self.user.objectID, self.transact) as session:
result = yield self.facade.getNamespace(session, u'username',
False, False, True)
self.assertEqual([u'tag'], result.tags)
def testGetNamespaceWithTags(self):
"""
L{Facade.getNamespace} includes child L{Tag.name}s, if they were
requested.
"""
createTag(self.user, self.user.namespace, u'tag')
self.store.commit()
with login(u'username', self.user.objectID, self.transact) as session:
result = yield self.facade.getNamespace(session, u'username',
False, False, True)
self.assertEqual([u'tag'], result.tags)
def testGetTagPermissions(self):
"""
L{getTagPermissions} returns the L{Tag}s and L{TagPermission}s that
match the specified L{Tag.path}s.
"""
user = createUser(u'name', u'password', u'Name', u'*****@*****.**')
namespace = createNamespace(user, u'name')
createTag(user, namespace, u'unwanted')
tag = createTag(user, namespace, u'tag')
permission = createTagPermission(tag)
self.assertEqual((tag, permission),
getTagPermissions([u'name/tag']).one())
def testGetChildTags(self):
"""
L{getChildTag} returns the child L{Namespace}s for the specified
parent L{Namespace} paths.
"""
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
namespace = createNamespace(user, u'ignored')
createTag(user, namespace, u'child')
tag = createTag(user, user.namespace, u'child')
self.assertEqual(tag, getChildTags([u'username']).one())
def testCreateWithExistingTagPath(self):
"""
L{NamespaceAPI.create} can be used to create L{Namespace}s with the
same path as an existing L{Namespace}.
"""
createTag(self.user, self.user.namespace, u'name')
values = [(u'username/name', u'A description')]
self.namespaces.create(values)
result = self.store.find(Namespace, Namespace.path == u'username/name')
namespace = result.one()
self.assertEqual(u'username/name', namespace.path)
self.assertEqual(u'name', namespace.name)
self.assertIdentical(self.user.namespace, namespace.parent)
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())
def testGetWithTags(self):
"""
L{NamespaceAPI.get} can optionally include the names of child L{Tag}s
in the result.
"""
createTag(self.user, self.user.namespace, u'tag')
self.assertEqual(
{
'username': {
'id': self.user.namespace.objectID,
'tagNames': [u'tag']
}
}, self.namespaces.get([u'username'], withTags=True))
def testCreateWithExistingTagPath(self):
"""
L{NamespaceAPI.create} can be used to create L{Namespace}s with the
same path as an existing L{Namespace}.
"""
createTag(self.user, self.user.namespace, u'name')
values = [(u'username/name', u'A description')]
self.namespaces.create(values)
result = self.store.find(Namespace, Namespace.path == u'username/name')
namespace = result.one()
self.assertEqual(u'username/name', namespace.path)
self.assertEqual(u'name', namespace.name)
self.assertIdentical(self.user.namespace, namespace.parent)
def testGetTagPathsAndObjectIDs(self):
"""
L{getTagPathsAndObjectIDs} returns a C{(Tag.path, objectID)} 2-tuples
that match the specified object IDs.
"""
objectID = uuid4()
user = createUser(u'user', u'secret', u'User', u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag = createTag(user, user.namespace, u'name1')
createTag(user, user.namespace, u'name2')
createTagValue(user.id, tag.id, objectID, 42)
createTagValue(user.id, tag.id, uuid4(), 17)
self.assertEqual((tag.path, objectID),
getTagPathsAndObjectIDs([objectID]).one())
def testGetTagPathsForObjectIDs(self):
"""
L{getTagPathsForObjectIDs} returns the unique set of L{Tag.path}s that
match the specified object IDs.
"""
objectID1 = uuid4()
objectID2 = uuid4()
user = createUser(u'user', u'secret', u'User', u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag = createTag(user, user.namespace, u'name1')
createTag(user, user.namespace, u'name2')
createTagValue(user.id, tag.id, objectID1, 42)
createTagValue(user.id, tag.id, objectID2, 17)
result = getTagPathsForObjectIDs([objectID1, objectID2])
self.assertEqual(u'user/name1', result.one())
def testGetTags(self):
"""L{getTags} returns all L{Tag}s in the database, by default."""
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag = createTag(user, user.namespace, u'name')
self.assertEqual(tag, getTags().one())
def 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 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 testUniqueFileIDAndValueID(self):
"""
An C{IntegrityError} is raised if an L{OpaqueValueLink} with the same
fileID and valueID is added to the database. Duplicated C{tag_id} or
C{file_id} can be added as long as the pair is unique.
"""
user = createUser(u'name', u'password', u'User', u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag = createTag(user, user.namespace, u'tag')
value1 = TagValue(user.id, tag.id, uuid4(), None)
value2 = TagValue(user.id, tag.id, uuid4(), None)
self.store.add(value1)
self.store.add(value2)
self.store.flush()
fileID1 = 'f' * 64
fileID2 = '0' * 64
self.store.add(OpaqueValue(fileID1, 'content1'))
self.store.add(OpaqueValue(fileID2, 'content2'))
# Add an initial link
self.store.add(OpaqueValueLink(value1.id, fileID1))
# Add link with the same fileID but different valueID. It should work.
self.store.add(OpaqueValueLink(value2.id, fileID1))
# Add link with the same valueID but different fileID. It should work.
self.store.add(OpaqueValueLink(value1.id, fileID2))
self.store.flush()
# Add link with same fileID and valueID. It should fail.
self.store.add(OpaqueValueLink(value1.id, fileID1))
self.assertRaises(IntegrityError, self.store.flush)
self.store.rollback()
def _createTags(self, values, parentNamespaces):
"""Create new tags.
@param values: A sequence of C{(Tag.path, description)} 2-tuples.
@param parentNamespaces: A C{dict} mapping L{Namespace.path}s to
L{Namespace} instances, the parents of the new L{Tag}s.
@return: A C{list} of C{(objectID, Tag.path)} 2-tuples.
"""
admin = getUser(u'fluiddb')
objects = self._factory.objects(admin)
systemValues = {}
result = []
tags = []
for path, description in values:
parentPath = getParentPath(path)
name = getPathName(path)
parentNamespace = parentNamespaces.get(parentPath)
tag = createTag(self._user, parentNamespace, name)
tag.objectID = objects.create(
u'Object for the attribute %s' % path)
result.append((tag.objectID, path))
systemValues[tag.objectID] = {
u'fluiddb/tags/description': description,
u'fluiddb/tags/path': path
}
tags.append(tag)
self._createPermissions(tags)
if systemValues:
self._factory.tagValues(admin).set(systemValues)
return result
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 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 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 testCreateTagAddsToStore(self):
"""L{createTag} adds the new L{Tag} to the main store."""
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
user.namespaceID = createNamespace(user, user.username, None).id
tag = createTag(user, user.namespace, u'tag')
result = self.store.find(Tag, Tag.path == u'username/tag')
self.assertIdentical(tag, result.one())
def testFloatValue(self):
"""A L{TagValue} can store a C{float} value."""
objectID = uuid4()
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
namespace = createNamespace(user, u'name')
tag = createTag(user, namespace, u'tag')
self.store.add(TagValue(user.id, tag.id, objectID, 42.1))
def testUnicodeSetValue(self):
"""A L{TagValue} can store a C{list} of C{unicode} values."""
objectID = uuid4()
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
namespace = createNamespace(user, u'name')
tag = createTag(user, namespace, u'tag')
self.store.add(TagValue(user.id, tag.id, objectID, [u'foo', u'bar']))
def 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 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 testValues(self):
"""
L{TagValueCollection.values} returns a L{ResultSet} that yields all
available L{Tag} values, when no filtering has been applied.
"""
objectID = uuid4()
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
namespace = createNamespace(user, u'name')
tag1 = createTag(user, namespace, u'tag1')
tag2 = createTag(user, namespace, u'tag2')
tagValue1 = TagValue(user.id, tag1.id, objectID, 42)
tagValue2 = TagValue(user.id, tag2.id, objectID, u'foo')
self.store.add(tagValue1)
self.store.add(tagValue2)
collection = TagValueCollection()
self.assertEqual(sorted([(tag1, tagValue1), (tag2, tagValue2)]),
sorted(collection.values()))
def testValuesWithPaths(self):
"""
A L{TagValueCollection} filtered by path only contains values for
L{Tag}s with a matching path.
"""
objectID = uuid4()
user = createUser(u'username', u'password', u'User',
u'*****@*****.**')
namespace = createNamespace(user, u'name')
tag1 = createTag(user, namespace, u'tag1')
tag2 = createTag(user, namespace, u'tag2')
self.store.add(TagValue(user.id, tag1.id, objectID, None))
self.store.add(TagValue(user.id, tag2.id, objectID, 42))
collection = TagValueCollection(paths=[u'name/tag1'])
(tag, tagValue) = collection.values().one()
self.assertEqual(objectID, tagValue.objectID)
self.assertEqual(u'name/tag1', tag.path)
self.assertEqual(None, tagValue.value)
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 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 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 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 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 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 _createTags(self):
"""Create tags."""
superuser = self.users[u'fluiddb']
for tag in self._data['tags']:
path = tag['path']
parentPath = getParentPath(path)
name = getPathName(path)
parentNamespace = self.namespaces[parentPath]
tagObject = createTag(superuser, parentNamespace, name)
self._createTagPermissions(tagObject)
self.tags[path] = tagObject
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{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 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 setUp(self):
super(BatchIndexTest, self).setUp()
# We use low-level functions here instead of model API methods because
# we want to avoid an automatic update of the objects table.
user = createUser(u'username', u'secret', u'User', u'*****@*****.**')
namespace = createNamespace(user, u'username', None)
tag = createTag(user, namespace, u'tag')
self.userID = user.id
self.tagID = tag.id
tempPath = self.config.get('service', 'temp-path')
self.objectsFilename = os.path.join(tempPath, 'objects.txt')
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 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())
