diff --git a/tests/test_list.py b/tests/test_list.py
index 17f9e5baae10215f86a35cd28015548ae6a30607..a62d4895ac501d57553a94a0c92e1be550c66ff2 100644
--- a/tests/test_list.py
+++ b/tests/test_list.py
@@ -27,9 +27,10 @@
 """
 import os
 import caosdb as db
-from caosdb.exceptions import TransactionError
+from caosdb.exceptions import (TransactionError,
+                               UnqualifiedPropertiesError)
 from nose.tools import nottest, assert_true, assert_raises, assert_equal
-from pytest import mark
+from pytest import mark, raises
 
 
 def setup():
@@ -63,9 +64,9 @@ def test_list_of_files():
                 db.FILE),
             value=[
                 file_.id]).insert()
-    assert_true(rec.is_valid())
+    assert rec.is_valid()
 
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.Record(
             name="TestRecNotOk").add_parent(recty).add_property(
                 name="TestListProperty",
@@ -73,9 +74,9 @@ def test_list_of_files():
                     db.FILE),
                 value=[
                     p.id]).insert()
-    assert_equal(
-        tr_err.exception.errors[0].msg,
-        "Reference not qualified. The value of this Reference Property is to be a child of its data type.")
+    assert tr_err.value.has_error(UnqualifiedPropertiesError)
+    assert (tr_err.value.get_errors()[0].get_errors()[0].msg ==
+            "Reference not qualified. The value of this Reference Property is to be a child of its data type.")
 
 
 def test_list_datatype_know():
@@ -205,36 +206,35 @@ def test_error_on_wrong_value():
             db.INTEGER)).insert()
     assert_true(p.is_valid())
 
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.RecordType(
             name="TestRT").add_property(
                 name="TestListProperty",
                 value=["this is not an int"]).insert()
-    assert_equal(tr_err.exception.msg, "Entity has unqualified properties.")
-    assert_equal(
-        tr_err.exception.get_errors()[0].msg,
-        "Cannot parse value to integer.")
+    assert tr_err.value.has_error(UnqualifiedPropertiesError)
+    assert (tr_err.value.get_errors()[0].get_errors()[0].msg ==
+            "Cannot parse value to integer.")
 
 
 def test_data_type_with_non_existing_ref1():
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.Property(name="TestListProperty",
                     datatype=db.LIST("non_existing")).insert()
-    assert_equal(tr_err.exception.msg, "Unknown datatype.")
+    assert tr_err.value.get_errors()[0].msg == "Unknown datatype."
 
 
 def test_data_type_with_non_existing_ref2():
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.Property(
             name="TestListProperty",
             datatype=db.LIST(234233234)).insert()
-    assert_equal(tr_err.exception.msg, "Unknown datatype.")
+    assert tr_err.value.get_errors()[0].msg == "Unknown datatype."
 
 
 def test_data_type_with_non_existing_ref3():
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.Property(name="TestListProperty", datatype=db.LIST(-2341)).insert()
-    assert_equal(tr_err.exception.msg, "Unknown datatype.")
+    assert tr_err.value.get_errors()[0].msg == "Unknown datatype."
 
 
 def test_data_type_with_existing_ref1():
@@ -373,44 +373,45 @@ def test_single_ref_value_scope_error():
     rt2 = db.RecordType(name="TestRT2").insert()
     db.Property(name="TestProp", datatype=db.LIST(rt2)).insert()
 
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.RecordType(
             name="TestRT3").add_property(
                 name="TestProp",
                 value=[rec]).insert()
-    assert_equal(
-        tr_err.exception.get_errors()[0].msg,
-        "Reference not qualified. The value of this Reference Property is to be a child of its data type.")
+    assert tr_err.value.has_error(UnqualifiedPropertiesError)
+    assert (tr_err.value.get_errors()[0].get_errors()[0].msg ==
+            "Reference not qualified. The value of this Reference " +
+            "Property is to be a child of its data type.")
 
 
 def test_error_single_non_existing_ref_value():
     rt = db.RecordType(name="TestRT").insert()
     db.Property(name="TestProp", datatype=db.LIST(rt)).insert()
 
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.RecordType(
             name="TestRT2").add_property(
                 name="TestProp",
                 value=["non_existing"]).insert()
-    assert_equal(
-        tr_err.exception.get_errors()[0].msg,
-        "Referenced entity does not exist.")
+    assert tr_err.value.has_error(UnqualifiedPropertiesError)
+    assert (tr_err.value.get_errors()[0].get_errors()[0].msg ==
+            "Referenced entity does not exist.")
 
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.RecordType(
             name="TestRT2").add_property(
                 name="TestProp",
                 value=[213425234234]).insert()
-    assert_equal(
-        tr_err.exception.get_errors()[0].msg,
-        "Referenced entity does not exist.")
+    assert tr_err.value.has_error(UnqualifiedPropertiesError)
+    assert (tr_err.value.get_errors()[0].get_errors()[0].msg ==
+            "Referenced entity does not exist.")
 
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.RecordType(name="TestRT2").add_property(
             name="TestProp", value=[-1234]).insert()
-    assert_equal(
-        tr_err.exception.get_errors()[0].msg,
-        "Referenced entity does not exist.")
+    assert tr_err.value.has_error(UnqualifiedPropertiesError)
+    assert (tr_err.value.get_errors()[0].get_errors()[0].msg ==
+            "Referenced entity does not exist.")
 
 
 def test_error_multi_non_existing_ref_value():
@@ -419,7 +420,7 @@ def test_error_multi_non_existing_ref_value():
     db.Record(name="TestRec2").add_parent(name="TestRT").insert()
     db.Property(name="TestProp", datatype=db.LIST(rt)).insert()
 
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.RecordType(
             name="TestRT2").add_property(
                 name="TestProp",
@@ -427,11 +428,11 @@ def test_error_multi_non_existing_ref_value():
                     "TestRec1",
                     "non_existing",
                     "TestRec2"]).insert()
-    assert_equal(
-        tr_err.exception.get_errors()[0].msg,
-        "Referenced entity does not exist.")
+    assert tr_err.value.has_error(UnqualifiedPropertiesError)
+    assert (tr_err.value.get_errors()[0].get_errors()[0].msg ==
+            "Referenced entity does not exist.")
 
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.RecordType(
             name="TestRT2").add_property(
             name="TestProp",
@@ -439,18 +440,18 @@ def test_error_multi_non_existing_ref_value():
                     213425234234,
                     "TestRec2",
                     "TestRec1"]).insert()
-    assert_equal(
-        tr_err.exception.get_errors()[0].msg,
-        "Referenced entity does not exist.")
+    assert tr_err.value.has_error(UnqualifiedPropertiesError)
+    assert (tr_err.value.get_errors()[0].get_errors()[0].msg ==
+            "Referenced entity does not exist.")
 
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.RecordType(
             name="TestRT2").add_property(
                 name="TestProp", value=[
                     "TestRec1", "TestRec2", -1234]).insert()
-    assert_equal(
-        tr_err.exception.get_errors()[0].msg,
-        "Referenced entity does not exist.")
+    assert tr_err.value.has_error(UnqualifiedPropertiesError)
+    assert (tr_err.value.get_errors()[0].get_errors()[0].msg ==
+            "Referenced entity does not exist.")
 
 
 def test_multi_ref_value_scope_error():
@@ -462,7 +463,7 @@ def test_multi_ref_value_scope_error():
     db.Record(name="TestRec2").add_parent(name="TestRT2").insert()
     db.Property(name="TestProp", datatype=db.LIST(rt2)).insert()
 
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.RecordType(
             name="TestRT3").add_property(
                 name="TestProp",
@@ -470,9 +471,10 @@ def test_multi_ref_value_scope_error():
                     rec,
                     "TestRec1",
                     "TestRec2"]).insert()
-    assert_equal(
-        tr_err.exception.get_errors()[0].msg,
-        "Reference not qualified. The value of this Reference Property is to be a child of its data type.")
+    assert tr_err.value.has_error(UnqualifiedPropertiesError)
+    assert (tr_err.value.get_errors()[0].get_errors()[0].msg ==
+            "Reference not qualified. The value of this Reference " +
+            "Property is to be a child of its data type.")
 
 
 def test_multi_ref_value():
@@ -635,29 +637,30 @@ def test_list_of_references():
             name="Test_RT1",
             datatype=db.LIST("Test_RT1")).insert()
     p = rt2.get_properties()[0]
-    assert_equal(p.id, rt1.id)
-    assert_equal(p.name, rt1.name)
-    assert_equal(p.datatype, db.LIST(rt1.name))
+    assert p.id == rt1.id
+    assert p.name == rt1.name
+    assert p.datatype == db.LIST(rt1.name)
 
     p = db.execute_query("FIND Test_RT2", unique=True).get_properties()[0]
-    assert_equal(p.id, rt1.id)
-    assert_equal(p.name, rt1.name)
-    assert_equal(p.datatype, db.LIST(rt1.name))
+    assert p.id == rt1.id
+    assert p.name == rt1.name
+    assert p.datatype == db.LIST(rt1.name)
 
     rt1rec1 = db.Record(name="Test_RT1_Rec1").add_parent("Test_RT1").insert()
-    assert_true(rt1rec1.is_valid())
+    assert rt1rec1.is_valid()
 
-    with assert_raises(TransactionError) as tr_err:
+    with raises(TransactionError) as tr_err:
         db.Record(
             name="Test_RT2_Rec").add_parent("Test_RT2").add_property(
                 name="Test_RT1",
                 value=[rt1rec1]).insert()
-    assert_equal(
-        tr_err.exception.get_errors()[0].msg,
-        'This datatype does not accept collections of values (e.g. Lists).')
+    print(tr_err.value)
+    assert tr_err.value.has_error(UnqualifiedPropertiesError)
+    assert (tr_err.value.get_errors()[0].get_errors()[0].msg ==
+            'This datatype does not accept collections of values (e.g. Lists).')
     rt2rec = db.Record(name="Test_RT2_Rec").add_parent("Test_RT2").add_property(
         name="Test_RT1", datatype=db.LIST("Test_RT1"), value=[rt1rec1]).insert()
-    assert_true(rt2rec.is_valid())
+    assert rt2rec.is_valid()
 
 
 def test_list_in_sub_property():
diff --git a/tests/test_tickets_200.py b/tests/test_tickets_200.py
index 19255cc9f3a9cb74468bfd58454f6e2726e0ba40..b3dbd003e1693ea08884facf68db01a9ae8e9805 100644
--- a/tests/test_tickets_200.py
+++ b/tests/test_tickets_200.py
@@ -327,10 +327,11 @@ def test_ticket_239():
             p, value="SimpleRecord3")
 
         c = h.Container().extend([rec4])
-        assert_raises(h.TransactionError, c.insert)
-        assert_equal(c[0].get_property(
-            "SimpleReferenceProperty").get_errors()[0].description,
-            "Referenced entity does not exist.")
+        with raises(h.TransactionError) as te:
+            c.insert()
+        assert te.value.has_error(h.UnqualifiedPropertiesError)
+        assert c[0].get_property("SimpleReferenceProperty").get_errors()[
+            0].description == "Referenced entity does not exist."
 
         rec3 = h.Record(name="SimpleRecord3").add_parent(rt)
         c = h.Container().extend([rec3, rec4]).insert()
@@ -570,5 +571,9 @@ def test_ticket_233():
     e1 = h.Entity("sdlkavhjawriluvyruksvnkuhndb")
     e2 = h.Entity("ösdlkavhjawriluvyruksvnkuhndb")
 
-    assert_raises(h.EntityDoesNotExistError, e1.retrieve)
-    assert_raises(h.EntityDoesNotExistError, e2.retrieve)
+    with raises(h.TransactionError) as te:
+        e1.retrieve()
+    assert te.value.has_error(h.EntityDoesNotExistError)
+    with raises(h.TransactionError) as te:
+        e2.retrieve()
+    assert te.value.has_error(h.EntityDoesNotExistError)