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 testGetChildNamespaces(self): """ L{getChildNamespace} returns the child L{Namespace}s for the specified parent paths. """ user = createUser(u'username', u'password', u'User', u'*****@*****.**') createNamespace(user, u'ignored') parent = createNamespace(user, u'parent') child = createNamespace(user, u'parent/child', parent.id) self.assertEqual(child, getChildNamespaces([u'parent']).one())
def testGetChildNamespacesOnlyConsidersDirectDescendants(self): """ L{getChildNamespace} only returns L{Namespace}s that are direct descendants of the specified parent paths. """ user = createUser(u'username', u'password', u'User', u'*****@*****.**') parent = createNamespace(user, u'parent') child = createNamespace(user, u'parent/child', parent.id) createNamespace(user, u'parent/child/grandchild', child.id) self.assertEqual(child, getChildNamespaces([u'parent']).one())
def testCreateNamespaceWithUnknownParent(self): """ L{Facade.createNamespace} raises a L{TNonexistentNamespace} exception if a non-existent parent L{Namespace} is specified. """ createNamespace(self.user, u'username/name', self.user.namespace.id) self.store.commit() with login(u'username', self.user.objectID, self.transact) as session: deferred = self.facade.createNamespace(session, u'unknown/parent', u'name', u'A namespace.') yield self.assertFailure(deferred, TNonexistentNamespace)
def testCreateNamespaceWithUnknownParent(self): """ L{Facade.createNamespace} raises a L{TNonexistentNamespace} exception if a non-existent parent L{Namespace} is specified. """ createNamespace(self.user, u'username/name', self.user.namespace.id) self.store.commit() with login(u'username', self.user.objectID, self.transact) as session: deferred = self.facade.createNamespace(session, u'unknown/parent', u'name', u'A namespace.') yield self.assertFailure(deferred, TNonexistentNamespace)
def testCreateNamespaceWithExistingPath(self): """ L{Facade.createNamespace} raises a L{TNamespaceAlreadyExists} exception if the new L{Namespace} already exists. """ createNamespace(self.user, u'username/name', self.user.namespace.id) self.store.commit() with login(u'username', self.user.objectID, self.transact) as session: deferred = self.facade.createNamespace(session, u'username', u'name', u'A namespace.') yield self.assertFailure(deferred, TNamespaceAlreadyExists)
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 testCreateNamespaceWithExistingPath(self): """ L{Facade.createNamespace} raises a L{TNamespaceAlreadyExists} exception if the new L{Namespace} already exists. """ createNamespace(self.user, u'username/name', self.user.namespace.id) self.store.commit() with login(u'username', self.user.objectID, self.transact) as session: deferred = self.facade.createNamespace(session, u'username', u'name', u'A namespace.') yield self.assertFailure(deferred, TNamespaceAlreadyExists)
def testGetNamespaces(self): """ L{getNamespaces} returns all L{Namespace}s in the database, by default. """ user = createUser(u'username', u'password', u'User', u'*****@*****.**') user.namespaceID = createNamespace(user, user.username, None).id namespace = createNamespace(user, u'name') result = getNamespaces() self.assertEqual([namespace, user.namespace], list(result.order_by(Namespace.path)))
def testGetWithNamespaces(self): """ L{NamespaceAPI.get} can optionally include the names of child L{Namespace} in the result. """ createNamespace(self.user, u'username/child', self.user.namespace.id) result = self.namespaces.get([u'username'], withNamespaces=True) result['username']['namespaceNames'].sort() self.assertEqual({'username': {'id': self.user.namespace.objectID, 'namespaceNames': [u'child', u'private']}}, result)
def testCreateWithExistingNamespacePath(self): """ L{TagAPI.create} can be used to create L{Tag}s with the same path as an existing L{Namespace}. """ createNamespace(self.user, u'username/name', self.user.namespace.id) values = [(u'username/name', u'A description')] self.tags.create(values) systemTags = self.system.tags.keys() tag = self.store.find(Tag, Not(Tag.path.is_in(systemTags))).one() self.assertEqual(u'username/name', tag.path) self.assertEqual(u'name', tag.name) self.assertIdentical(self.user.namespace, tag.namespace)
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 testGetWithNamespaces(self): """ L{NamespaceAPI.get} can optionally include the names of child L{Namespace} in the result. """ createNamespace(self.user, u'username/child', self.user.namespace.id) result = self.namespaces.get([u'username'], withNamespaces=True) result['username']['namespaceNames'].sort() self.assertEqual( { 'username': { 'id': self.user.namespace.objectID, 'namespaceNames': [u'child', u'private'] } }, 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 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 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 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 testCreateNamespaceAddsToStore(self): """L{createNamespace} adds the new L{Namespace} to the main store.""" user = createUser(u'username', u'password', u'User', u'*****@*****.**') namespace = createNamespace(user, u'name') result = self.store.find(Namespace, Namespace.name == u'name') self.assertIdentical(namespace, result.one())
def create(self, values): """Create new L{Namespace}s. Missing parent L{Namespace}s are created automatically. For example, if C{foo/bar/baz} is requested, and C{foo/bar} doesn't already exist, it will be created before C{foo/bar/baz} is created. Associated L{NamespacePermission}s are created automatically with the system-wide default permissions. @param values: A sequence of C{(path, description)} 2-tuples. @raises DuplicatePathError: Raised if the path for a new L{Namespace} collides with an existing one. @raise MalformedPathError: Raised if one of the given paths is empty or has unacceptable characters. @return: A C{list} of C{(objectID, path)} 2-tuples for the new L{Namespace}s. """ from fluiddb.model.user import getUser if not values: return [] paths = [path for path, description in values] descriptions = dict(values) self._checkForDuplicates(paths) admin = getUser(u'fluiddb') objects = self._factory.objects(admin) systemValues = {} paths = getPathHierarchy(paths) existingNamespaces = dict((namespace.path, namespace) for namespace in getNamespaces(paths=paths)) newNamespaces = [] for path in sorted(paths): if path in existingNamespaces: continue parentPath = getParentPath(path) parentID = (existingNamespaces[parentPath].id if parentPath is not None else None) namespace = createNamespace(self._user, path, parentID) aboutValue = u'Object for the namespace %s' % path description = descriptions.get(path, aboutValue) namespace.objectID = objects.create(aboutValue) systemValues[namespace.objectID] = { u'fluiddb/namespaces/description': description, u'fluiddb/namespaces/path': path, u'fluiddb/about': aboutValue} existingNamespaces[path] = namespace newNamespaces.append(namespace) self._createPermissions(newNamespaces) self._factory.tagValues(admin).set(systemValues) values = [(namespace.objectID, namespace.path) for namespace in newNamespaces] return values
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 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 setUp(self): super(GetRecentActivityTest, self).setUp() self.user1 = createUser(u'user1', 'hash', u'User', u'*****@*****.**') self.user2 = createUser(u'user2', 'hash', u'User', u'*****@*****.**') self.user3 = createUser(u'user3', 'hash', u'User', u'*****@*****.**') self.user1.namespaceID = createNamespace(self.user1, self.user1.username, None).id self.user2.namespaceID = createNamespace(self.user2, self.user2.username, None).id self.user3.namespaceID = createNamespace(self.user3, self.user3.username, None).id self.user1tag1 = createTag(self.user1, self.user1.namespace, u'tag1') self.user1tag2 = createTag(self.user1, self.user1.namespace, u'tag2') self.user2tag1 = createTag(self.user2, self.user2.namespace, u'tag1') self.user2tag2 = createTag(self.user2, self.user2.namespace, u'tag2') self.user3tag1 = createTag(self.user3, self.user3.namespace, u'tag1') self.user3tag2 = createTag(self.user3, self.user3.namespace, u'tag2')
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 setUp(self): super(TagValueIntegrityCheckerTest, self).setUp() self.system = createSystemData() self.user = createUser(u'user', u'pass', u'Name', u'*****@*****.**') self.parent = createNamespace(self.user, u'user', None) self.user.namespaceID = self.parent.id self.checker = TagValueIntegrityChecker() self.superuser = self.system.users[u'fluiddb']
def testGet(self): """ L{NamespaceAPI.get} returns L{Namespace}s that match the specified paths. """ namespace = createNamespace(self.user, u'namespace') self.assertEqual({'namespace': {'id': namespace.objectID}}, self.namespaces.get([u'namespace']))
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 setUp(self): super(TagValueIntegrityCheckerTest, self).setUp() self.system = createSystemData() self.user = createUser(u'user', u'pass', u'Name', u'*****@*****.**') self.parent = createNamespace(self.user, u'user', None) self.user.namespaceID = self.parent.id self.checker = TagValueIntegrityChecker() self.superuser = self.system.users[u'fluiddb']
def setUp(self): super(GetRecentActivityTest, self).setUp() self.user1 = createUser(u'user1', 'hash', u'User', u'*****@*****.**') self.user2 = createUser(u'user2', 'hash', u'User', u'*****@*****.**') self.user3 = createUser(u'user3', 'hash', u'User', u'*****@*****.**') self.user1.namespaceID = createNamespace(self.user1, self.user1.username, None).id self.user2.namespaceID = createNamespace(self.user2, self.user2.username, None).id self.user3.namespaceID = createNamespace(self.user3, self.user3.username, None).id self.user1tag1 = createTag(self.user1, self.user1.namespace, u'tag1') self.user1tag2 = createTag(self.user1, self.user1.namespace, u'tag2') self.user2tag1 = createTag(self.user2, self.user2.namespace, u'tag1') self.user2tag2 = createTag(self.user2, self.user2.namespace, u'tag2') self.user3tag1 = createTag(self.user3, self.user3.namespace, u'tag1') self.user3tag2 = createTag(self.user3, self.user3.namespace, u'tag2')
def testGet(self): """ L{NamespaceAPI.get} returns L{Namespace}s that match the specified paths. """ namespace = createNamespace(self.user, u'namespace') self.assertEqual({'namespace': { 'id': namespace.objectID }}, self.namespaces.get([u'namespace']))
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 testCreateTagWithMalformedPath(self): """ L{createTag} raises a L{MalformedPathError} if an invalid path is provided. """ user = createUser(u'username', u'password', u'User', u'*****@*****.**') user.namespaceID = createNamespace(user, user.username, None).id self.assertRaises(MalformedPathError, createTag, user, user.namespace, u'')
def 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 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 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 testGetObjectIDsWithUnknownObjectID(self): """ L{getObjectIDs} doesn't return any results if unknown tag paths are provided. """ user = createUser(u'user', u'secret', u'User', u'*****@*****.**') user.namespaceID = createNamespace(user, user.username, None).id tag = createTag(user, user.namespace, u'name1') createTagValue(user.id, tag.id, uuid4(), 42) self.assertEqual([], list(getObjectIDs([u'user/name2'])))
def testGetNamespacesWithObjectIDs(self): """ When L{Namespace.objectIDs}s are provided L{getNamespaces} returns matching L{Namespace}s. """ user = createUser(u'username', u'password', u'User', u'*****@*****.**') namespace = createNamespace(user, u'name') result = getNamespaces(objectIDs=[namespace.objectID]) self.assertIdentical(namespace, result.one())
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 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 testGetWithDescriptions(self): """ L{NamespaceAPI.get} can optionally include L{Namespace.description}s in the result. """ descriptionTag = self.system.tags[u'fluiddb/namespaces/description'] namespace = createNamespace(self.user, u'namespace') createTagValue(self.user.id, descriptionTag.id, namespace.objectID, u'A namespace') result = self.namespaces.get([u'namespace'], withDescriptions=True) self.assertEqual(namespace.objectID, result['namespace']['id']) self.assertEqual(u'A namespace', result['namespace']['description'])
def setUp(self): super(NamespaceIntegrityCheckerTest, self).setUp() system = createSystemData() self.user = createUser(u'user', u'pass', u'Name', u'*****@*****.**') self.superuser = system.users[u'fluiddb'] self.anonymous = system.users[u'anon'] self.parent = createNamespace(self.user, u'user', None) self.user.namespaceID = self.parent.id self.descriptionTag = system.tags['fluiddb/namespaces/description'] self.pathTag = system.tags['fluiddb/namespaces/path'] self.aboutTag = system.tags['fluiddb/about'] self.checker = NamespaceIntegrityChecker()
def testUniquePathConstraint(self): """ An C{IntegrityError} is raised if a L{Tag} with a duplicate path is added to the database. """ user = createUser(u'name', u'password', u'User', u'*****@*****.**') user.namespaceID = createNamespace(user, user.username, None).id self.store.add(Tag(user, user.namespace, u'name/tag', u'tag')) self.store.flush() self.store.add(Tag(user, user.namespace, u'name/tag', u'tag')) self.assertRaises(IntegrityError, self.store.flush) self.store.rollback()
def 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 _createNamespaces(self): """Create L{Namespace}s.""" superuser = self.users[u'fluiddb'] for namespaceData in self._data['namespaces']: path = namespaceData['path'] parentPath = getParentPath(path) parentNamespace = self.namespaces.get(parentPath, None) parentID = parentNamespace.id if parentNamespace else None namespace = createNamespace(superuser, path, parentID) self._createNamespacePermissions(namespace) self.namespaces[path] = namespace if path in self.users: self.users[path].namespaceID = namespace.id
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 testCreateNamespace(self): """L{createNamespace} creates a new L{Namespace}.""" user = createUser(u'username', u'password', u'User', u'*****@*****.**') namespace = createNamespace(user, u'name') self.assertEqual(u'name', namespace.path) self.assertEqual(u'name', namespace.name) self.assertIdentical(None, namespace.parentID) self.assertNotIdentical(None, namespace.objectID) self.assertNotIdentical(None, namespace.creationTime) self.assertIdentical(user, namespace.creator) self.assertIdentical(None, namespace.parent) self.assertIdentical(None, namespace.children.one())
def 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 testUniqueObjectIDConstraint(self): """ An C{IntegrityError} is raised if a L{Tag} with a duplicate object ID is added to the database. """ user = createUser(u'name', u'password', u'User', u'*****@*****.**') user.namespaceID = createNamespace(user, user.username, None).id tag1 = Tag(user, user.namespace, u'name/tag1', u'tag1') self.store.add(tag1) self.store.flush() tag2 = Tag(user, user.namespace, u'name/tag2', u'tag2') tag2.objectID = tag1.objectID self.store.add(tag2) self.assertRaises(IntegrityError, self.store.flush) self.store.rollback()