Refactor tests to py.test

pydbc/tests/base.py

@@ -1,5 +1,4 @@
 
-#import unittest
 import pytest
 
 from pydbc.api.db import Database
@@ -12,6 +11,3 @@ class BaseTest:
     def setup_database(self, db_in_memory):
         self.db = db_in_memory
 
-#    def tearDown(self):
-#        self.db.close()
-

pydbc/tests/test_attributes.py

@@ -30,7 +30,7 @@ def testUpdateWorkx(self):
         attr.valueType = ValueType.FLOAT
         attr.objectType = AttributeType.ENV_VAR
         attr.update()
-        attr = AttributeDefinition(self.db, 42, "ABC", AttributeType.ENV_VAR, ValueType.FLOAT, 0, comment ="world")
+        attr = AttributeDefinition(self.db, 42, "ABC", AttributeType.ENV_VAR, ValueType.FLOAT, 0, comment = "world")
         assert attr.objectType == AttributeType.ENV_VAR
         assert attr.valueType == ValueType.FLOAT
         assert attr.comment == "world"
@@ -40,21 +40,13 @@ def testUpdateFails(self):
 
     def testRidCouldNotBeSet(self):
       attr = self.createAttribute()
-      try:
+      with pytest.raises(AttributeError):
           attr.rid = 0
-      except AttributeError:
-          pass
-      except Exception as e:
-          raise
 
     def testDatabaseCouldNotBeSet(self):
       attr = self.createAttribute()
-      try:
+      with pytest.raises(AttributeError):
           attr.database = None
-      except AttributeError:
-          pass
-      except Exception:
-          raise
 
     def testSetNameWorks(self):
         attr = self.createAttribute()
@@ -78,21 +70,13 @@ def testSetObjectTypeWorks2(self):
 
     def testSetObjectTypeFails1(self):
         attr = self.createAttribute()
-        try:
+        with pytest.raises(ValueError):
             attr.objectType = 112
-        except ValueError:
-            pass
-        except Exception:
-            raise
 
     def testSetObjectTypeFail21(self):
         attr = self.createAttribute()
-        try:
+        with pytest.raises(ValueError):
             attr.objectType = "hello"
-        except ValueError:
-            pass
-        except Exception:
-            raise
 
     def testSetLimitsWorks(self):
         attr = self.createAttribute()

pydbc/tests/test_createdb.py

@@ -1,14 +1,12 @@
 
-import unittest
+import pytest
 
 from pydbc.api.db import Database
 
 
-class TestCreation(unittest.TestCase):
+class TestCreation:
 
-  def testCreateDatabase(self):
-    db = Database("test")
-
-
-if __name__ == '__main__':
-  unittest.main()
+    def testCreateDatabase(self):
+        db = Database("test")
+        assert db.dbname == "test.vndb"
+        assert db.dbtype == "CAN"

pydbc/tests/test_messages.py

@@ -1,6 +1,6 @@
 
 from pprint import pprint
-import unittest
+import pytest
 
 from pydbc.tests.base import BaseTest
 from pydbc.api.db import DuplicateKeyError
@@ -15,19 +15,20 @@ def createMessage(self):
 
     def testInsertMessageWorks(self):
         msg = self.createMessage()
-        self.assertEqual(msg.name, "MSG")
-        self.assertEqual(msg.identifier, 0x0815)
-        self.assertEqual(msg.dlc, 4)
-        self.assertEqual(msg.comment, "test-message")
+        assert msg.name == "MSG"
+        assert msg.identifier == 0x0815
+        assert msg.dlc == 4
+        assert msg.comment == "test-message"
 
     def testInsertDuplicateMessageFails(self):
         msg1 = self.createMessage()
-        self.assertRaises(DuplicateKeyError, self.createMessage)
+        with pytest.raises(DuplicateKeyError):
+            self.createMessage()
 
     def testNewlyCreatedMessageHasNoSignals(self):
         msg = self.createMessage()
         signals = list(msg.signals())
-        self.assertEqual(signals, [])
+        assert signals == []
 
     def testAddSignalWorks(self):
         msg = self.createMessage()
@@ -36,32 +37,32 @@ def testAddSignalWorks(self):
     def testSignalTypeUintWorks(self):
         msg = self.createMessage()
         signal = msg.addSignal("Drehzahl", 4, 8, ByteOrderType.INTEL, SignalType.UINT, "rpm", Formula(), Limits())
-        self.assertEqual(signal.valueType, SignalType.UINT)
+        assert signal.valueType == SignalType.UINT
 
     def testSignalTypeSintWorks(self):
         msg = self.createMessage()
         signal = msg.addSignal("Drehzahl", 4, 8, ByteOrderType.INTEL, SignalType.SINT, "rpm", Formula(), Limits())
-        self.assertEqual(signal.valueType, SignalType.SINT)
+        assert signal.valueType == SignalType.SINT
 
     def testSignalTypeFloat32Works(self):
         msg = self.createMessage()
         signal = msg.addSignal("Drehzahl", 4, 8, ByteOrderType.INTEL, SignalType.FLOAT32, "rpm", Formula(), Limits())
-        self.assertEqual(signal.valueType, SignalType.FLOAT32)
+        assert signal.valueType == SignalType.FLOAT32
 
     def testSignalTypeFloat64Works(self):
         msg = self.createMessage()
         signal = msg.addSignal("Drehzahl", 4, 8, ByteOrderType.INTEL, SignalType.FLOAT64, "rpm", Formula(), Limits())
-        self.assertEqual(signal.valueType, SignalType.FLOAT64)
+        assert signal.valueType == SignalType.FLOAT64
 
     def testSignalByteOrderIntelWorks(self):
         msg = self.createMessage()
         signal = msg.addSignal("Drehzahl", 4, 8, ByteOrderType.INTEL, SignalType.UINT, "rpm", Formula(), Limits())
-        self.assertEqual(signal.byteOrder, ByteOrderType.INTEL)
+        assert signal.byteOrder == ByteOrderType.INTEL
 
     def testSignalByteOrderMotorolaWorks(self):
         msg = self.createMessage()
         signal = msg.addSignal("Drehzahl", 4, 8, ByteOrderType.MOTOROLA, SignalType.UINT, "rpm", Formula(), Limits())
-        self.assertEqual(signal.byteOrder, ByteOrderType.MOTOROLA)
+        assert signal.byteOrder == ByteOrderType.MOTOROLA
 
     def testUpdateWorks(self):
         msg = self.createMessage()
@@ -70,17 +71,18 @@ def testUpdateWorks(self):
         msg.dlc = 8
         msg.comment = "hello"
         msg.update()
-        self.assertEqual(msg.name, "MSG2")
-        self.assertEqual(msg.identifier, 0x4711)
-        self.assertEqual(msg.dlc, 8)
-        self.assertEqual(msg.comment, "hello")
+        assert msg.name == "MSG2"
+        assert msg.identifier == 0x4711
+        assert msg.dlc == 8
+        assert msg.comment == "hello"
 
     def testUpdateFails(self):
         msg = self.createMessage()
         msg2 = self.db.addMessage("MSG2", 0x4711, 8)
         msg2.name = "MSG"
         msg2.dlc = 7
-        self.assertRaises(DuplicateKeyError, msg2.update)
+        with pytest.raises(DuplicateKeyError):
+            msg2.update()
 
 
 

pydbc/tests/test_node.py

@@ -1,6 +1,6 @@
 
 from pprint import pprint
-import unittest
+import pytest
 
 from pydbc.tests.base import BaseTest
 from pydbc.api.db import DuplicateKeyError
@@ -10,23 +10,24 @@ class TestNode(BaseTest):
 
   def testDummyNodeExists(self):
     node = list(self.db.nodes())[0]
-    self.assertEqual(node.name, "Vector__XXX")
-    self.assertEqual(node.comment, "Dummy node for non-existent senders/receivers.")
+    assert node.name == "Vector__XXX"
+    assert node.comment == "Dummy node for non-existent senders/receivers."
 
   def testInsertNodeWorkx(self):
     node = self.db.addNode("ABC", "test-node")
-    self.assertEqual(node.name, "ABC")
-    self.assertEqual(node.comment, "test-node")
+    assert node.name == "ABC"
+    assert node.comment == "test-node"
 
   def testNodeNameShallBeUnique(self):
     self.db.addNode("ABC", "test-node")
-    self.assertRaises(DuplicateKeyError, self.db.addNode, "ABC", "test-node")
+    with pytest.raises(DuplicateKeyError):
+        self.db.addNode("ABC", "test-node")
 
   def testNodeDeletionWorkx(self):
     node = self.db.addNode("ABC", "test-node")
     node.remove()
     node = self.db.node("ABC")
-    self.assertIsNone(node)
+    assert node is None
 
 
   def testUpdateWorkx(self):
@@ -35,65 +36,55 @@ def testUpdateWorkx(self):
     node.comment = "foo bar"
     node.update()
     node = self.db.node("ABC")
-    self.assertIsNone(node)
+    assert node is None
     node = self.db.node("DEF")
-    self.assertEqual(node.name, "DEF")
-    self.assertEqual(node.comment, "foo bar")
+    assert node.name == "DEF"
+    assert node.comment == "foo bar"
 
 
   def testUpdateFails1(self):
     node = self.db.addNode("ABC", "test-node")
     self.db.addNode("DEF", "test-node")
     node.name = "DEF"
-    self.assertRaises(DuplicateKeyError, node.update)
+    with pytest.raises(DuplicateKeyError):
+        node.update()
 
   def testUpdateFails2(self):
     node = self.db.addNode("ABC", "test-node")
-    self.assertRaises(TypeError, node.name, 45.35)
+    with pytest.raises(TypeError):
+        node.name = 45.35
 
   def testUpdateFails3(self):
     node = self.db.addNode("ABC", "test-node")
-    self.assertRaises(TypeError, node.comment, 47.11)
+    with pytest.raises(TypeError):
+        node.comment = 47.11
 
   def testRidCouldNotBeSet(self):
     node = self.db.addNode("ABC", "test-node")
-    try:
+    with pytest.raises(AttributeError):
       node.rid = 0
-    except AttributeError:
-      pass
-    except Exception as e:
-      raise
 
   def testDatabaseCouldNotBeSet(self):
     node = self.db.addNode("ABC", "test-node")
-    try:
+    with pytest.raises(AttributeError):
       node.database = None
-    except AttributeError:
-      pass
-    except Exception:
-      raise
-
-  @unittest.skip
-  def testNodeAttrs(self):
-    #nodes = [n for n in self.db.nodes(regex = ".*Unit")]
-    nodes = [n for n in self.db.nodes()]
-    print(nodes)
-    n0= nodes[0]
-    n0.comment = "Hello world comment!!!"
-    print("\n\n\n", n0.name)
-    for n in nodes:
-      print("***", n.name)
-      for attr in n.attributes:
-        print(attr)
-    print("AV:", attr.value)
-    attr.value = "TestECU"
-    print("New AV:", attr)
-    attr.update()
-    attr = n.attribute("NmJ1939IndustryGroup")
-    attr = n.attribute("ECU")
-    print(attr)
-    self.db.db.commitTransaction()
-
-if __name__ == '__main__':
-  unittest.main()
 
+  #  def testNodeAttrs(self):
+  #    #nodes = [n for n in self.db.nodes(regex = ".*Unit")]
+  #    nodes = [n for n in self.db.nodes()]
+  #    print(nodes)
+  #    n0= nodes[0]
+  #    n0.comment = "Hello world comment!!!"
+  #    print("\n\n\n", n0.name)
+  #    for n in nodes:
+  #      print("***", n.name)
+  #      for attr in n.attributes:
+  #        print(attr)
+  #    print("AV:", attr.value)
+  #    attr.value = "TestECU"
+  #    print("New AV:", attr)
+  #    attr.update()
+  #    attr = n.attribute("NmJ1939IndustryGroup")
+  #    attr = n.attribute("ECU")
+  #    print(attr)
+  #    self.db.db.commitTransaction()