diff --git a/tests/test_permissions.py b/tests/test_permissions.py
index 6e042040424d31682b019d77d5cb2d8e114e3609..69aab490fe11b5c6073e0c91c3cbe1e7fd033aee 100644
--- a/tests/test_permissions.py
+++ b/tests/test_permissions.py
@@ -319,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)
@@ -340,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
@@ -362,7 +362,7 @@ 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)
@@ -370,18 +370,18 @@ def test_update_acl():
 
 @ 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")
 
@@ -391,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)
 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:*")
@@ -415,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)
 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")
@@ -445,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)
 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)
 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)
 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)
 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()