def testReadonlyObjectIsNotCached(self): """Readonly objects are not cached or tracked by Storm.""" self.store.execute( """ INSERT INTO users (object_id, role, username, password_hash, fullname, email) VALUES (?, ?, ?, ?, ?, ?) """, (uuid4(), 1, u'username', u'secret', u'name', u'*****@*****.**')) readonly(self.store.find(User)).one() self.store.flush() self.assertEqual([], self.store._cache.get_cached())
def testSet(self): """ C{ResultSet.set} raises a C{RuntimeError} if its been put in readonly mode. """ result = readonly(self.store.find(User)) self.assertRaises(RuntimeError, result.set, username=u'hello')
def getTagPermissions(self, paths): """Get L{Permission}s for L{Tag.path}s. @param paths: A sequence of L{Tag.path}s to retrieve L{Permission}s for. @return: A C{dict} mapping L{Tag.path}s to L{Permission} instances. """ return dict((tag.path, permission) for tag, permission in readonly(getTagPermissions(paths)))
def getNamespacePermissions(self, paths): """Get L{Permission}s for L{Namespace.path}s. @param paths: A sequence of L{Namespace.path}s to retrieve L{Permission}s for. @return: A C{dict} mapping L{Namespace.path}s to L{Permission} instances. """ return dict((namespace.path, permission) for namespace, permission in readonly( getNamespacePermissions(paths)))
def getNamespacePermissions(self, paths): """Get L{Permission}s for L{Namespace.path}s. @param paths: A sequence of L{Namespace.path}s to retrieve L{Permission}s for. @return: A C{dict} mapping L{Namespace.path}s to L{Permission} instances. """ return dict((namespace.path, permission) for namespace, permission in readonly(getNamespacePermissions(paths)))
def testReadonlyWithNonObjectResult(self): """ A readonly C{ResultSet} correctly handles non-object result values, such as a count in a C{GROUP BY} query. """ user = createUser(u'username', u'secret', u'name', u'*****@*****.**') result = readonly(self.store.find((Count(), User.username))) result.group_by(User.username) count, readonlyUser = result.one() self.assertEqual(1, count) readonlyUser = readonly(self.store.find(User)).one() self.assertNotIdentical(user, readonlyUser) self.assertEqual(user.id, readonlyUser.id) self.assertEqual(user.objectID, readonlyUser.objectID) self.assertEqual(user.username, readonlyUser.username) self.assertEqual(user.passwordHash, readonlyUser.passwordHash) self.assertEqual(user.fullname, readonlyUser.fullname) self.assertEqual(user.email, readonlyUser.email) self.assertEqual(user.namespaceID, readonlyUser.namespaceID) self.assertEqual(user.creationTime, readonlyUser.creationTime)
def testReadonly(self): """ L{readonly} returns readonly objects using data from a C{ResultSet}. """ user = createUser(u'username', u'secret', u'name', u'*****@*****.**') readonlyUser = readonly(self.store.find(User)).one() self.assertNotIdentical(user, readonlyUser) self.assertEqual(user.id, readonlyUser.id) self.assertEqual(user.objectID, readonlyUser.objectID) self.assertEqual(user.username, readonlyUser.username) self.assertEqual(user.passwordHash, readonlyUser.passwordHash) self.assertEqual(user.fullname, readonlyUser.fullname) self.assertEqual(user.email, readonlyUser.email) self.assertEqual(user.namespaceID, readonlyUser.namespaceID) self.assertEqual(user.creationTime, readonlyUser.creationTime)
def _getTagPermissions(self, values): """Get L{TagPermission}s for the specified values. @param values: A sequence of C{(Tag.path, Operation)} 2-tuples. @return: A C{dict} that maps C{(Tag.path, Operation)} 2-tuples to C{(Policy, exceptions)} 2-tuples, matching the following format:: {(<path>, <operation>): (<policy>, [<user-id>, ...]), ...} """ permissionIndex = {} paths = set(path for path, operation in values) for tag, permission in readonly(getTagPermissions(paths)): permissionIndex[tag.path] = permission permissions = {} for path, operation in values: permission = permissionIndex[path] policy, exceptions = permission.get(operation) permissions[(path, operation)] = (policy, exceptions) return permissions
def testReadonlyWithTupleResult(self): """L{readonly} correctly handles tuple results.""" user = createUser(u'username', u'secret', u'name', u'*****@*****.**') namespace = createNamespace(user, u'username') permission = createNamespacePermission(namespace) result = getNamespacePermissions([u'username']) readonlyNamespace, readonlyPermission = readonly(result).one() self.assertNotIdentical(namespace, readonlyNamespace) self.assertEqual(namespace.id, readonlyNamespace.id) self.assertEqual(namespace.objectID, readonlyNamespace.objectID) self.assertEqual(namespace.parentID, readonlyNamespace.parentID) self.assertEqual(namespace.creatorID, readonlyNamespace.creatorID) self.assertEqual(namespace.path, readonlyNamespace.path) self.assertEqual(namespace.name, readonlyNamespace.name) self.assertEqual(namespace.creationTime, readonlyNamespace.creationTime) self.assertNotIdentical(permission, readonlyPermission) self.assertEqual(permission.createPolicy, readonlyPermission.createPolicy) self.assertEqual(permission.createExceptions, readonlyPermission.createExceptions) self.assertEqual(permission.updatePolicy, readonlyPermission.updatePolicy) self.assertEqual(permission.updateExceptions, readonlyPermission.updateExceptions) self.assertEqual(permission.deletePolicy, readonlyPermission.deletePolicy) self.assertEqual(permission.deleteExceptions, readonlyPermission.deleteExceptions) self.assertEqual(permission.listPolicy, readonlyPermission.listPolicy) self.assertEqual(permission.listExceptions, readonlyPermission.listExceptions) self.assertEqual(permission.controlPolicy, readonlyPermission.controlPolicy) self.assertEqual(permission.controlExceptions, readonlyPermission.controlExceptions)
def testReadonlyWithEmptyResult(self): """ L{readonly} returns an empty C{list} if the C{ResultSet} is empty. """ result = self.store.find(User) self.assertEqual([], list(readonly(result)))