diff --git a/tests/test_permissions.py b/tests/test_permissions.py
index 423355976c868d901e19a088d5d79333b859657b..b8728d922a1e5aad38db333a96bb984842d086bb 100644
--- a/tests/test_permissions.py
+++ b/tests/test_permissions.py
@@ -195,7 +195,6 @@ def test_basic_acl_stuff():
     assert_false("DELETE" in other_role_permissions)
 
 
-@with_setup(setup, teardown)
 def test_query():
     person = db.RecordType("TestPerson").insert()
     db.Property("TestFirstName", datatype=db.TEXT).insert()
@@ -210,30 +209,21 @@ def test_query():
         name="TestConductor",
         value=dan.id).insert()
 
-    assert_equal(
-        db.execute_query(
-            "FIND TestExperiment WHICH HAS A TestConductor->TestPerson",
-            unique=True).id,
-        exp.id)
-    assert_equal(
-        db.execute_query(
-            "FIND TestExperiment WHICH HAS A TestConductor=TestPerson",
-            unique=True).id,
-        exp.id)
-    assert_equal(
-        db.execute_query(
-            "FIND TestExperiment WHICH HAS A TestConductor=" + str(dan.id),
-            unique=True).id, exp.id)
-    assert_equal(
-        db.execute_query(
-            "FIND TestExperiment",
-            unique=True).id,
-        exp.id)
-    assert_equal(
-        db.execute_query(
-            "FIND TestExperiment WHICH HAS A TestConductor WHICH has a TestFirstName=Daniel",
-            unique=True).id,
-        exp.id)
+    assert db.execute_query(
+        "FIND TestExperiment WHICH HAS A TestConductor->TestPerson",
+        unique=True).id == exp.id
+    assert db.execute_query(
+        "FIND TestExperiment WHICH HAS A TestConductor=TestPerson",
+        unique=True).id == exp.id
+    assert db.execute_query(
+        "FIND TestExperiment WHICH HAS A TestConductor=" + str(dan.id),
+        unique=True).id == exp.id
+    assert db.execute_query(
+        "FIND TestExperiment",
+        unique=True).id == exp.id
+    assert db.execute_query(
+        "FIND TestExperiment WHICH HAS A TestConductor WHICH has a TestFirstName=Daniel",
+        unique = True).id == exp.id
 
     '''success'''
     grant_permission(person, "RETRIEVE:*")
@@ -241,11 +231,9 @@ def test_query():
     grant_permission(exp, "RETRIEVE:*")
 
     switch_to_test_user()
-    assert_equal(
-        db.execute_query(
-            "FIND TestExperiment WHICH HAS A TestConductor WHICH has a TestFirstName=Daniel",
-            unique=True).id,
-        exp.id)
+    assert db.execute_query(
+        "FIND TestExperiment WHICH HAS A TestConductor WHICH has a TestFirstName=Daniel",
+        unique = True).id == exp.id
 
     '''failure - dan'''
     deny_permission(dan, "RETRIEVE:*")
@@ -253,37 +241,34 @@ def test_query():
 
     # this fails if server is configured with
     # QUERY_FILTER_ENTITIES_WITHOUT_RETRIEVE_PERMISSIONS = FALSE
-    with raises(db.TransactionError) as cm:
+    with raises(db.EmptyUniqueQueryError):
         db.execute_query(
             "FIND TestExperiment WHICH HAS A TestConductor WHICH has a TestFirstName=Daniel",
-            unique=True)
-    assert cm.value.has_error(db.EntityDoesNotExistError)
+            unique = True)
     '''... but works without the which clause'''
-    assert db.execute_query("FIND TestExperiment", unique=True).id == exp.id
+    assert db.execute_query("FIND TestExperiment", unique = True).id == exp.id
     '''and with the id'''
     assert db.execute_query(
         "FIND TestExperiment WHICH HAS A TestConductor=" + str(dan.id),
-        unique=True).id == exp.id
+        unique = True).id == exp.id
 
     '''failure - exp'''
     grant_permission(dan, "RETRIEVE:*")
     deny_permission(exp, "RETRIEVE:*")
     switch_to_test_user()
 
-    with raises(db.TransactionError) as cm:
+    with raises(db.EmptyUniqueQueryError):
         db.execute_query(
             "FIND TestExperiment WHICH HAS A TestConductor=TestDaniel",
-            unique=True)
-    assert cm.value.has_error(db.EntityDoesNotExistError)
+            unique = True)
 
-    with raises(db.TransactionError) as cm:
-        db.execute_query("FIND TestExperiment", unique=True)
-    assert cm.value.has_error(db.EntityDoesNotExistError)
+    with raises(db.EmptyUniqueQueryError):
+        db.execute_query("FIND TestExperiment", unique = True)
 
 
-@with_setup(setup, teardown)
+@ with_setup(setup, teardown)
 def test_update_acl():
-    p = db.Property(name="TestProperty", datatype=db.TEXT).insert()
+    p=db.Property(name = "TestProperty", datatype = db.TEXT).insert()
     assert_true(p.is_valid())
     assert_is_none(p.acl)
     p.retrieve_acl()
@@ -293,24 +278,24 @@ def test_update_acl():
         "USE:AS_DATA_TYPE" in p.acl.get_permissions_for_user(
             db.get_config().get("Connection", "username")))
     p.acl.deny(
-        username=db.get_config().get("Connection", "username"),
-        permission="USE:AS_DATA_TYPE")
+        username = db.get_config().get("Connection", "username"),
+        permission = "USE:AS_DATA_TYPE")
     assert_false(
         "USE:AS_DATA_TYPE" in p.acl.get_permissions_for_user(
             db.get_config().get("Connection", "username")))
 
     '''Success'''
-    p.update(flags={"ACL": None})
+    p.update(flags = {"ACL": None})
     assert_true(p.is_valid())
     assert_is_not_none(p.acl)
     assert_false(
         "USE:AS_DATA_TYPE" in p.acl.get_permissions_for_user(
             db.get_config().get("Connection", "username")))
 
-    p2 = db.execute_query(
+    p2=db.execute_query(
         "FIND TestProperty",
-        unique=True,
-        flags={
+        unique = True,
+        flags = {
             "ACL": None})
     assert_true(p2.is_valid())
     assert_is_not_none(p2.acl)
@@ -325,8 +310,8 @@ def test_update_acl():
         "EDIT:ACL" in p2.acl.get_permissions_for_user(
             db.get_config().get("Connection", "username")))
     p2.acl.deny(
-        username=db.get_config().get("Connection", "username"),
-        permission="EDIT:ACL")
+        username = db.get_config().get("Connection", "username"),
+        permission = "EDIT:ACL")
     assert_false(
         "EDIT:ACL" in p2.acl.get_permissions_for_user(
             db.get_config().get("Connection", "username")))
@@ -334,10 +319,10 @@ def test_update_acl():
     '''Success'''
     p2.update()
 
-    p3 = db.execute_query(
+    p3=db.execute_query(
         "FIND TestProperty",
-        unique=True,
-        flags={
+        unique = True,
+        flags = {
             "ACL": None})
     assert_true(p3.is_valid())
     assert_is_not_none(p3.acl)
@@ -355,16 +340,16 @@ def test_update_acl():
     '''Failure'''
     p.retrieve_acl()
     p3.acl.deny(
-        username=db.get_config().get("Connection", "username"),
-        permission="USE:AS_PROPERTY")
+        username = db.get_config().get("Connection", "username"),
+        permission = "USE:AS_PROPERTY")
     with raises(db.TransactionError) as te:
         p3.update_acl()
     assert te.value.has_error(db.AuthorizationException)
 
-    p3 = db.execute_query(
+    p3=db.execute_query(
         "FIND TestProperty",
-        unique=True,
-        flags={
+        unique = True,
+        flags = {
             "ACL": None})
     assert p3.is_valid()
     assert p3.acl is not None
@@ -377,26 +362,26 @@ def test_update_acl():
 
     '''Failure'''
     switch_to_test_user()
-    p3.acl.grant(username=test_user, permission="EDIT:ACL")
+    p3.acl.grant(username = test_user, permission = "EDIT:ACL")
     with raises(db.TransactionError) as te:
         p3.update()
     assert te.value.has_error(db.AuthorizationException)
 
 
-@with_setup(setup, teardown)
+@ with_setup(setup, teardown)
 def test_update_name():
-    p = db.Property(name="TestProperty", datatype=db.TEXT).insert()
+    p=db.Property(name = "TestProperty", datatype = db.TEXT).insert()
     assert_true(p.is_valid())
 
     grant_permission(p, "RETRIEVE:*")
     grant_permission(p, "UPDATE:*")
 
     '''Success'''
-    p.name = "TestPropertyNew"
+    p.name="TestPropertyNew"
     assert_is_none(p.acl)
     p.update()
 
-    p2 = db.execute_query("FIND Test*", unique=True)
+    p2=db.execute_query("FIND Test*", unique = True)
     assert_true(p.is_valid())
     assert_equal(p2.name, "TestPropertyNew")
 
@@ -406,22 +391,22 @@ def test_update_name():
     p.retrieve()
     assert_false("UPDATE:NAME" in p.permissions)
 
-    p.name = "TestPropertyEvenNewer"
+    p.name="TestPropertyEvenNewer"
     with raises(db.TransactionError) as te:
         p.update()
     assert te.value.has_error(db.AuthorizationException)
 
-    p2 = db.execute_query("FIND Test*", unique=True)
+    p2=db.execute_query("FIND Test*", unique = True)
     assert p2.is_valid()
     assert p2.name == "TestPropertyNew"
 
 
-@with_setup(setup, teardown)
+@ with_setup(setup, teardown)
 def test_update_desc():
-    p = db.Property(
-        name="TestProperty",
-        description="Description",
-        datatype=db.TEXT).insert()
+    p=db.Property(
+        name = "TestProperty",
+        description = "Description",
+        datatype = db.TEXT).insert()
     assert_true(p.is_valid())
 
     grant_permission(p, "RETRIEVE:*")
@@ -430,29 +415,29 @@ def test_update_desc():
     '''Success'''
     switch_to_test_user()
     assert_equal(p.description, "Description")
-    p.description = "DescriptionNew"
+    p.description="DescriptionNew"
     p.update()
 
-    p2 = db.execute_query("FIND Test*", unique=True)
+    p2=db.execute_query("FIND Test*", unique = True)
     assert_true(p.is_valid())
     assert_equal(p2.description, "DescriptionNew")
 
     deny_permission(p, "UPDATE:DESCRIPTION")
 
     '''Failure'''
-    p.description = "DescriptionEvenNewer"
+    p.description="DescriptionEvenNewer"
     with raises(db.TransactionError) as te:
         p.update()
     assert te.value.has_error(db.AuthorizationException)
 
-    p2 = db.execute_query("FIND Test*", unique=True)
+    p2=db.execute_query("FIND Test*", unique = True)
     assert p2.is_valid()
     assert p2.description == "DescriptionNew"
 
 
-@with_setup(setup, teardown)
+@ with_setup(setup, teardown)
 def test_update_data_type():
-    p = db.Property(name="TestProperty", datatype=db.TEXT).insert()
+    p=db.Property(name = "TestProperty", datatype = db.TEXT).insert()
     assert_true(p.is_valid())
 
     grant_permission(p, "RETRIEVE:ENTITY")
@@ -460,125 +445,125 @@ def test_update_data_type():
 
     '''Success'''
     assert_equal(p.datatype, db.TEXT)
-    p.datatype = db.INTEGER
+    p.datatype=db.INTEGER
     p.update()
 
-    p2 = db.execute_query("FIND Test*", unique=True)
+    p2=db.execute_query("FIND Test*", unique = True)
     assert_true(p.is_valid())
     assert_equal(p2.datatype, db.INTEGER)
 
     deny_permission(p, "UPDATE:DATA_TYPE")
 
     '''Failure'''
-    p.datatype = db.DOUBLE
+    p.datatype=db.DOUBLE
     with raises(db.TransactionError) as te:
         p.update()
     assert te.value.has_error(db.AuthorizationException)
 
-    p2 = db.execute_query("FIND Test*", unique=True)
+    p2=db.execute_query("FIND Test*", unique = True)
     assert p2.is_valid()
     assert p2.datatype == db.INTEGER
 
 
-@with_setup(setup, teardown)
+@ with_setup(setup, teardown)
 def test_update_role():
-    p = db.Property(name="TestProperty", datatype=db.TEXT).insert()
+    p=db.Property(name = "TestProperty", datatype = db.TEXT).insert()
     assert_true(p.is_valid())
 
     grant_permission(p, "RETRIEVE:ENTITY")
     grant_permission(p, "UPDATE:ROLE")
 
     '''Success'''
-    rt = db.RecordType(name="TestProperty").retrieve()
+    rt=db.RecordType(name = "TestProperty").retrieve()
     rt.update()
 
-    rt2 = db.execute_query("FIND TestProperty", unique=True)
+    rt2=db.execute_query("FIND TestProperty", unique = True)
     assert_true(isinstance(rt2, db.RecordType))
 
     deny_permission(p, "UPDATE:ROLE")
 
     '''Failure'''
-    rec = db.Record(name="TestProperty").retrieve()
+    rec=db.Record(name = "TestProperty").retrieve()
     with raises(db.TransactionError) as te:
         rec.update()
     assert te.value.has_error(db.AuthorizationException)
 
-    rt2 = db.execute_query("FIND Test*", unique=True)
+    rt2=db.execute_query("FIND Test*", unique = True)
     assert rt2.is_valid()
     assert isinstance(rt2, db.RecordType)
 
 
-@with_setup(setup, teardown)
+@ with_setup(setup, teardown)
 def test_update_move_file():
-    upload_file = open("test.dat", "w")
+    upload_file=open("test.dat", "w")
     upload_file.write("hello world\n")
     upload_file.close()
 
-    f = db.File(
-        name="TestFile",
-        path="/permissiontestfiles/test.dat",
-        file="test.dat").insert()
+    f=db.File(
+        name = "TestFile",
+        path = "/permissiontestfiles/test.dat",
+        file = "test.dat").insert()
     assert_true(f.is_valid())
 
     grant_permission(f, "RETRIEVE:ENTITY")
     grant_permission(f, "UPDATE:FILE:MOVE")
 
     '''SUCCESS'''
-    f.path = "/otherpermissiontestfiles/test.dat"
+    f.path="/otherpermissiontestfiles/test.dat"
     f.update()
 
-    f2 = db.execute_query("FIND TestFile", unique=True)
+    f2=db.execute_query("FIND TestFile", unique = True)
     assert_equal(f2.path, "/otherpermissiontestfiles/test.dat")
 
     deny_permission(f, "UPDATE:FILE:MOVE")
 
     '''FAILURE'''
-    f.path = "/againotherpermissiontestfiles/test.dat"
+    f.path="/againotherpermissiontestfiles/test.dat"
     with raises(db.TransactionError) as te:
         f.update()
     assert te.value.has_error(db.AuthorizationException)
 
-    f2 = db.execute_query("FIND TestFile", unique=True)
+    f2=db.execute_query("FIND TestFile", unique = True)
     assert f2.path == "/otherpermissiontestfiles/test.dat"
 
 
-@with_setup(setup, teardown)
+@ with_setup(setup, teardown)
 def test_update_add_file():
-    upload_file = open("test.dat", "w")
+    upload_file=open("test.dat", "w")
     upload_file.write("test update add file: #here#\n")
     upload_file.close()
 
-    f = db.File(name="TestFile").insert()
+    f=db.File(name = "TestFile").insert()
     assert f.is_valid()
 
     grant_permission(f, "RETRIEVE:ENTITY")
     '''FAILURE'''
 
-    f.path = "/permissiontestfiles/newtest.dat"
-    f.file = upload_file
+    f.path="/permissiontestfiles/newtest.dat"
+    f.file=upload_file
     with raises(db.TransactionError) as te:
         f.update()
     assert te.value.has_error(db.AuthorizationException)
 
-    f2 = db.execute_query("FIND TestFile", unique=True)
+    f2=db.execute_query("FIND TestFile", unique = True)
     assert f2.path is None
 
     '''SUCCESS'''
     grant_permission(f, "UPDATE:FILE:ADD")
 
-    f2 = db.execute_query("FIND TestFile", unique=True)
-    f2.path = "/permissiontestfiles/newtest.dat"
-    f2.file = upload_file
+    f2=db.execute_query("FIND TestFile", unique = True)
+    f2.path="/permissiontestfiles/newtest.dat"
+    f2.file=upload_file
     f2.update()
     assert_true(f2.is_valid())
 
-    f2 = db.execute_query("FIND TestFile", unique=True)
+    f2=db.execute_query("FIND TestFile", unique = True)
     assert_equal(f2.path, "/permissiontestfiles/newtest.dat")
 
 
-@with_setup(setup, teardown)
+@ with_setup(setup, teardown)
 def test_update_change_file():
-    upload_file = open("test.dat", "w")
+    upload_file=open("test.dat", "w")
     upload_file.write("hello world\n")
     upload_file.close()
 
@@ -1210,7 +1195,7 @@ def test_check_entity_acl_roles():
     with raises(db.TransactionError) as cm:
         grant_permission(p, "USE:AS_PARENT", username="asdf-non-existing",
                          switch=False)
-    errors = cm.value.entities[0].errors
+    errors = cm.value.entities[0].get_errors()
     assert errors[0].description == "User Role does not exist."
     db.administration.set_server_property(
         "CHECK_ENTITY_ACL_ROLES_MODE", "SHOULD")