Unittest to pytest (#32366)

* add pytest-asyncio

* switch common

* switch selfdrive

* switch system

* switch tools

* small fixes

* fix setUp and valgrind pytest

* switch to setup

* fix random

* switch mock

* switch test_lateral_limits

* revert test_ui

* fix poetry.lock

* add unittest to banned-api

* add inline ignores to remaining unittest imports

* revert test_models

* revert check_can_parser_performance

* one more skip

---------

Co-authored-by: Adeeb Shihadeh <adeebshihadeh@gmail.com>

system/loggerd/tests/test_encoder.py

@@ -6,7 +6,6 @@ import random
 import shutil
 import subprocess
 import time
-import unittest
 from pathlib import Path
 
 from parameterized import parameterized
@@ -33,14 +32,14 @@ FILE_SIZE_TOLERANCE = 0.5
 
 
 @pytest.mark.tici # TODO: all of loggerd should work on PC
-class TestEncoder(unittest.TestCase):
+class TestEncoder:
 
-  def setUp(self):
+  def setup_method(self):
     self._clear_logs()
     os.environ["LOGGERD_TEST"] = "1"
     os.environ["LOGGERD_SEGMENT_LENGTH"] = str(SEGMENT_LENGTH)
 
-  def tearDown(self):
+  def teardown_method(self):
     self._clear_logs()
 
   def _clear_logs(self):
@@ -85,7 +84,7 @@ class TestEncoder(unittest.TestCase):
         file_path = f"{route_prefix_path}--{i}/{camera}"
 
         # check file exists
-        self.assertTrue(os.path.exists(file_path), f"segment #{i}: '{file_path}' missing")
+        assert os.path.exists(file_path), f"segment #{i}: '{file_path}' missing"
 
         # TODO: this ffprobe call is really slow
         # check frame count
@@ -98,13 +97,13 @@ class TestEncoder(unittest.TestCase):
         frame_count = int(probe.split('\n')[0].strip())
         counts.append(frame_count)
 
-        self.assertEqual(frame_count, expected_frames,
-                         f"segment #{i}: {camera} failed frame count check: expected {expected_frames}, got {frame_count}")
+        assert frame_count == expected_frames, \
+                         f"segment #{i}: {camera} failed frame count check: expected {expected_frames}, got {frame_count}"
 
         # sanity check file size
         file_size = os.path.getsize(file_path)
-        self.assertTrue(math.isclose(file_size, size, rel_tol=FILE_SIZE_TOLERANCE),
-                        f"{file_path} size {file_size} isn't close to target size {size}")
+        assert math.isclose(file_size, size, rel_tol=FILE_SIZE_TOLERANCE), \
+                        f"{file_path} size {file_size} isn't close to target size {size}"
 
         # Check encodeIdx
         if encode_idx_name is not None:
@@ -118,24 +117,24 @@ class TestEncoder(unittest.TestCase):
           frame_idxs = [m.frameId for m in encode_msgs]
 
           # Check frame count
-          self.assertEqual(frame_count, len(segment_idxs))
-          self.assertEqual(frame_count, len(encode_idxs))
+          assert frame_count == len(segment_idxs)
+          assert frame_count == len(encode_idxs)
 
           # Check for duplicates or skips
-          self.assertEqual(0, segment_idxs[0])
-          self.assertEqual(len(set(segment_idxs)), len(segment_idxs))
+          assert 0 == segment_idxs[0]
+          assert len(set(segment_idxs)) == len(segment_idxs)
 
-          self.assertTrue(all(valid))
+          assert all(valid)
 
-          self.assertEqual(expected_frames * i, encode_idxs[0])
+          assert expected_frames * i == encode_idxs[0]
           first_frames.append(frame_idxs[0])
-          self.assertEqual(len(set(encode_idxs)), len(encode_idxs))
+          assert len(set(encode_idxs)) == len(encode_idxs)
 
-      self.assertEqual(1, len(set(first_frames)))
+      assert 1 == len(set(first_frames))
 
       if TICI:
         expected_frames = fps * SEGMENT_LENGTH
-        self.assertEqual(min(counts), expected_frames)
+        assert min(counts) == expected_frames
       shutil.rmtree(f"{route_prefix_path}--{i}")
 
     try:
@@ -150,7 +149,3 @@ class TestEncoder(unittest.TestCase):
       managed_processes['encoderd'].stop()
       managed_processes['camerad'].stop()
       managed_processes['sensord'].stop()
-
-
-if __name__ == "__main__":
-  unittest.main()