WIP: Update more tests

tests/test_error_stuff.py

@@ -31,9 +31,12 @@ Created on 19.02.2015.
 
 """
 import caosdb as h
-from caosdb.exceptions import (EntityDoesNotExistError,
-                               UniqueNamesError, TransactionError, EntityError,
-                               UnqualifiedPropertiesError, EntityHasNoDatatypeError,
+from caosdb.exceptions import (ContainerError,
+                               EntityDoesNotExistError,
+                               EntityHasNoDatatypeError,
+                               UniqueNamesError, TransactionError,
+                               EntityError,
+                               UnqualifiedPropertiesError,
                                UnqualifiedParentsError)
 import pytest
 
@@ -72,9 +75,11 @@ def test_retrieval_exception_raised():
     with pytest.raises(TransactionError) as te:
         h.Property(name="Non-ExistentProperty").retrieve(unique=True,
                                                          raise_exception_on_error=True)
-    te = te.value
-    assert len(te.get_errors()) == 1
-    ee = te.get_errors()[0]
+    # retrieve returns a container, so treat that one separately
+    ce = te.value.get_errors()[0]
+    assert isinstance(ce, ContainerError)
+    assert len(ce.get_errors()) == 1
+    ee = ce.get_errors()[0]
     # Check for type incl. inheritance
     assert isinstance(ee, EntityDoesNotExistError)
     assert isinstance(ee, EntityError)
@@ -87,66 +92,40 @@ def test_retrieval_exception_raised():
 
 
 def test_insertion_no_exception_raised():
-    import caosdb as h
-    from nose.tools import assert_false, assert_true  # @UnresolvedImport
-
-    try:
-        p = h.Property(
-            name="NoTypeProperty").insert(
+    """Test whether insertion fails but no error is raised."""
+    p = h.Property(name="TestNoTypeProperty").insert(
         raise_exception_on_error=False)
-        assert_false(p.is_valid())
-        assert_true(p.id is None or p.id < 0)
-    finally:
-        try:
-            p.delete()
-        except BaseException:
-            pass
+    assert not p.is_valid()
+    assert (p.id is None or p.id < 0)
 
 
 def test_insertion_exception_raised():
-    import caosdb as h
-    from nose.tools import assert_true  # @UnresolvedImport
-
-    try:
-        p = h.Property(name="NoTypeProperty")
+    """Test insertion of a property with missing datatype."""
+    p = h.Property(name="TestNoTypeProperty")
+    with pytest.raises(TransactionError) as te:
         p.insert(raise_exception_on_error=True)
-        assert_true(False)
-    except EntityError as e:
-        print(e)
-    finally:
-        try:
-            p.delete()
-        except BaseException:
-            pass
+    assert te.value.has_error(EntityHasNoDatatypeError)
 
 
 def test_insertion_with_invalid_parents():
-    import caosdb as h
-    # @UnresolvedImport
-    from nose.tools import assert_false, assert_true, assert_is_not_none, assert_equal
-
-    try:
+    with pytest.raises(TransactionError) as te:
         p = h.Property(
-            name="NoTypeProperty",
+            name="TestNoTypeProperty",
             datatype="Text").add_parent(
             id=-1)
         p.insert(raise_exception_on_error=True)
-        assert_true(False)
-    except EntityError as e:
-        print(e)
-        assert_true(isinstance(e, UnqualifiedParentsError))
-        assert_is_not_none(e.get_entity())
-        assert_equal(e.get_entity().name, p.name)
-        assert_equal(e.get_entity().id, p.id)
-        assert_true(e.get_entity().has_errors())
-        assert_false(p.is_valid())
-        assert_false(e.get_entity().is_valid())
-        assert_is_not_none(e.get_entities())
-    finally:
-        try:
-            p.delete()
-        except BaseException:
-            pass
+    # TransactionError with ContainerError with
+    # UnqualifiedParentsError
+    upe = te.value.get_errors()[0].get_errors()[0]
+    print(upe)
+    assert isinstance(upe, UnqualifiedParentsError)
+    assert not upe.get_entity() is None
+    assert upe.get_entity().name == p.name
+    assert upe.get_entity().id == p.id
+    assert upe.get_entity().has_errors()
+    assert not p.is_valid()
+    assert not upe.get_entity().is_valid()
+    assert nt upe.get_entities() is not None
 
 
 def test_insertion_with_invalid_properties():