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 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 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 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 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())