tests: defer global imports and remove pytest parametrize decorators

Author: PhantomInTheWire

opendbc/car/tests/test_can_fingerprint.py

@@ -1,27 +1,28 @@
-import pytest
 from opendbc.car.can_definitions import CanData
-from opendbc.car.car_helpers import FRAME_FINGERPRINT, can_fingerprint
-from opendbc.car.fingerprints import _FINGERPRINTS as FINGERPRINTS
 
 
 class TestCanFingerprint:
-  @pytest.mark.parametrize("car_model, fingerprints", FINGERPRINTS.items())
-  def test_can_fingerprint(self, car_model, fingerprints):
+  def test_can_fingerprint(self):
     """Tests online fingerprinting function on offline fingerprints"""
+    from opendbc.car.car_helpers import can_fingerprint
+    from opendbc.car.fingerprints import _FINGERPRINTS as FINGERPRINTS
 
-    for fingerprint in fingerprints:  # can have multiple fingerprints for each platform
-      can = [CanData(address=address, dat=b'\x00' * length, src=src)
-             for address, length in fingerprint.items() for src in (0, 1)]
+    for car_model, fingerprints in FINGERPRINTS.items():
+      for fingerprint in fingerprints:  # can have multiple fingerprints for each platform
+        can = [CanData(address=address, dat=b'\x00' * length, src=src)
+               for address, length in fingerprint.items() for src in (0, 1)]
 
-      fingerprint_iter = iter([can])
-      car_fingerprint, finger = can_fingerprint(lambda **kwargs: [next(fingerprint_iter, [])])  # noqa: B023
+        fingerprint_iter = iter([can])
+        car_fingerprint, finger = can_fingerprint(lambda **kwargs: [next(fingerprint_iter, [])])  # noqa: B023
 
-      assert car_fingerprint == car_model
-      assert finger[0] == fingerprint
-      assert finger[1] == fingerprint
-      assert finger[2] == {}
+        assert car_fingerprint == car_model
+        assert finger[0] == fingerprint
+        assert finger[1] == fingerprint
+        assert finger[2] == {}
 
   def test_timing(self, subtests):
+    from opendbc.car.car_helpers import FRAME_FINGERPRINT, can_fingerprint
+    from opendbc.car.fingerprints import _FINGERPRINTS as FINGERPRINTS
     # just pick any CAN fingerprinting car
     car_model = "CHEVROLET_BOLT_EUV"
     fingerprint = FINGERPRINTS[car_model][0]

opendbc/car/tests/test_car_interfaces.py

@@ -1,132 +1,150 @@
 import os
 import math
-import hypothesis.strategies as st
-import pytest
-from hypothesis import Phase, given, settings
 from collections.abc import Callable
 from typing import Any
+from functools import lru_cache
 
 from opendbc.car import DT_CTRL, CanData, structs
-from opendbc.car.car_helpers import interfaces
-from opendbc.car.fingerprints import FW_VERSIONS
-from opendbc.car.fw_versions import FW_QUERY_CONFIGS
-from opendbc.car.interfaces import CarInterfaceBase, get_interface_attr
 from opendbc.car.mock.values import CAR as MOCK
-from opendbc.car.values import PLATFORMS
-
-DrawType = Callable[[st.SearchStrategy], Any]
-
-ALL_ECUS = {ecu for ecus in FW_VERSIONS.values() for ecu in ecus.keys()}
-ALL_ECUS |= {ecu for config in FW_QUERY_CONFIGS.values() for ecu in config.extra_ecus}
-
-ALL_REQUESTS = {tuple(r.request) for config in FW_QUERY_CONFIGS.values() for r in config.requests}
 
 # From panda/python/__init__.py
 DLC_TO_LEN = [0, 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 20, 24, 32, 48, 64]
 
 MAX_EXAMPLES = int(os.environ.get('MAX_EXAMPLES', '15'))
 
 
-def get_fuzzy_car_interface(car_name: str, draw: DrawType) -> CarInterfaceBase:
-  # Fuzzy CAN fingerprints and FW versions to test more states of the CarInterface
-  fingerprint_strategy = st.fixed_dictionaries({0: st.dictionaries(st.integers(min_value=0, max_value=0x800),
-                                                                   st.sampled_from(DLC_TO_LEN))})
-
-  # only pick from possible ecus to reduce search space
-  car_fw_strategy = st.lists(st.builds(
-    lambda fw, req: structs.CarParams.CarFw(ecu=fw[0], address=fw[1], subAddress=fw[2] or 0, request=req),
-    st.sampled_from(sorted(ALL_ECUS)),
-    st.sampled_from(sorted(ALL_REQUESTS)),
-  ))
+@lru_cache(maxsize=1)
+def _get_all_ecus():
+    """Lazy loader for ALL_ECUS"""
+    from opendbc.car.fingerprints import FW_VERSIONS
+    from opendbc.car.fw_versions import FW_QUERY_CONFIGS
 
-  params_strategy = st.fixed_dictionaries({
-    'fingerprints': fingerprint_strategy,
-    'car_fw': car_fw_strategy,
-    'alpha_long': st.booleans(),
-  })
+    all_ecus = {ecu for ecus in FW_VERSIONS.values() for ecu in ecus.keys()}
+    all_ecus |= {ecu for config in FW_QUERY_CONFIGS.values() for ecu in config.extra_ecus}
+    return all_ecus
 
-  params: dict = draw(params_strategy)
-  # reduce search space by duplicating CAN fingerprints across all buses
-  params['fingerprints'] |= {key + 1: params['fingerprints'][0] for key in range(6)}
 
-  # initialize car interface
-  CarInterface = interfaces[car_name]
-  car_params = CarInterface.get_params(car_name, params['fingerprints'], params['car_fw'],
-                                       alpha_long=params['alpha_long'], is_release=False, docs=False)
-  return CarInterface(car_params)
+@lru_cache(maxsize=1)
+def _get_all_requests():
+    """Lazy loader for ALL_REQUESTS"""
+    from opendbc.car.fw_versions import FW_QUERY_CONFIGS
+    return {tuple(r.request) for config in FW_QUERY_CONFIGS.values() for r in config.requests}
 
 
 class TestCarInterfaces:
-  # FIXME: Due to the lists used in carParams, Phase.target is very slow and will cause
-  #  many generated examples to overrun when max_examples > ~20, don't use it
-  @pytest.mark.parametrize("car_name", sorted(PLATFORMS))
-  @settings(max_examples=MAX_EXAMPLES, deadline=None,
-            phases=(Phase.reuse, Phase.generate, Phase.shrink))
-  @given(data=st.data())
-  def test_car_interfaces(self, car_name, data):
-    car_interface = get_fuzzy_car_interface(car_name, data.draw)
-    car_params = car_interface.CP.as_reader()
-
-    assert car_params.mass > 1
-    assert car_params.wheelbase > 0
-    # centerToFront is center of gravity to front wheels, assert a reasonable range
-    assert car_params.wheelbase * 0.3 < car_params.centerToFront < car_params.wheelbase * 0.7
-    assert car_params.maxLateralAccel > 0
-
-    # Longitudinal sanity checks
-    assert len(car_params.longitudinalTuning.kpV) == len(car_params.longitudinalTuning.kpBP)
-    assert len(car_params.longitudinalTuning.kiV) == len(car_params.longitudinalTuning.kiBP)
-
-    # Lateral sanity checks
-    if car_params.steerControlType != structs.CarParams.SteerControlType.angle:
-      tune = car_params.lateralTuning
-      if tune.which() == 'pid':
-        if car_name != MOCK.MOCK:
-          assert not math.isnan(tune.pid.kf) and tune.pid.kf > 0
-          assert len(tune.pid.kpV) > 0 and len(tune.pid.kpV) == len(tune.pid.kpBP)
-          assert len(tune.pid.kiV) > 0 and len(tune.pid.kiV) == len(tune.pid.kiBP)
-
-      elif tune.which() == 'torque':
-        assert not math.isnan(tune.torque.kf) and tune.torque.kf > 0
-        assert not math.isnan(tune.torque.friction) and tune.torque.friction > 0
-
-    # Run car interface
-    # TODO: use hypothesis to generate random messages
-    now_nanos = 0
-    CC = structs.CarControl().as_reader()
-    for _ in range(10):
-      car_interface.update([])
-      car_interface.apply(CC, now_nanos)
-      now_nanos += DT_CTRL * 1e9  # 10 ms
-
-    CC = structs.CarControl()
-    CC.enabled = True
-    CC.latActive = True
-    CC.longActive = True
-    CC = CC.as_reader()
-    for _ in range(10):
-      car_interface.update([])
-      car_interface.apply(CC, now_nanos)
-      now_nanos += DT_CTRL * 1e9  # 10ms
-
-    # Test radar interface
-    radar_interface = car_interface.RadarInterface(car_params)
-    assert radar_interface
-
-    # Run radar interface once
-    radar_interface.update([])
-    if not car_params.radarUnavailable and radar_interface.rcp is not None and \
-       hasattr(radar_interface, '_update') and hasattr(radar_interface, 'trigger_msg'):
-      radar_interface._update([radar_interface.trigger_msg])
-
-    # Test radar fault
-    if not car_params.radarUnavailable and radar_interface.rcp is not None:
-      cans = [(0, [CanData(0, b'', 0) for _ in range(5)])]
-      rr = radar_interface.update(cans)
-      assert rr is None or len(rr.errors) > 0
+  def test_car_interfaces(self, subtests):
+    import hypothesis.strategies as st
+    from hypothesis import Phase, given, settings
+    from opendbc.car.interfaces import CarInterfaceBase
+
+    DrawType = Callable[[st.SearchStrategy], Any]
+
+    def get_fuzzy_car_interface(car_name: str, draw: DrawType) -> CarInterfaceBase:
+      from opendbc.car.car_helpers import interfaces
+      # Fuzzy CAN fingerprints and FW versions to test more states of the CarInterface
+      fingerprint_strategy = st.fixed_dictionaries({0: st.dictionaries(st.integers(min_value=0, max_value=0x800),
+                                                                       st.sampled_from(DLC_TO_LEN))})
+      all_ecus = _get_all_ecus()
+      all_requests = _get_all_requests()
+
+      # only pick from possible ecus to reduce search space
+      car_fw_strategy = st.lists(st.builds(
+        lambda fw, req: structs.CarParams.CarFw(ecu=fw[0], address=fw[1], subAddress=fw[2] or 0, request=req),
+        st.sampled_from(sorted(all_ecus)),
+        st.sampled_from(sorted(all_requests)),
+      ))
+
+      params_strategy = st.fixed_dictionaries({
+        'fingerprints': fingerprint_strategy,
+        'car_fw': car_fw_strategy,
+        'alpha_long': st.booleans(),
+      })
+
+      params: dict = draw(params_strategy)
+      # reduce search space by duplicating CAN fingerprints across all buses
+      params['fingerprints'] |= {key + 1: params['fingerprints'][0] for key in range(6)}
+
+      # initialize car interface
+      CarInterface = interfaces[car_name]
+      car_params = CarInterface.get_params(car_name, params['fingerprints'],
+          params['car_fw'],alpha_long=params['alpha_long'], is_release=False, docs=False)
+      return CarInterface(car_params)
+
+    # FIXME: Due to the lists used in carParams, Phase.target is very slow and will cause
+    #  many generated examples to overrun when max_examples > ~20, don't use it
+    @settings(max_examples=MAX_EXAMPLES, deadline=None,
+              phases=(Phase.reuse, Phase.generate, Phase.shrink))
+    @given(data=st.data())
+    def run_car_interface_test(data, car_name: str):
+      car_interface = get_fuzzy_car_interface(car_name, data.draw)
+      car_params = car_interface.CP.as_reader()
+
+      assert car_params.mass > 1
+      assert car_params.wheelbase > 0
+      # centerToFront is center of gravity to front wheels, assert a reasonable range
+      assert car_params.wheelbase * 0.3 < car_params.centerToFront < car_params.wheelbase * 0.7
+      assert car_params.maxLateralAccel > 0
+
+      # Longitudinal sanity checks
+      assert len(car_params.longitudinalTuning.kpV) == len(car_params.longitudinalTuning.kpBP)
+      assert len(car_params.longitudinalTuning.kiV) == len(car_params.longitudinalTuning.kiBP)
+
+      # Lateral sanity checks
+      if car_params.steerControlType != structs.CarParams.SteerControlType.angle:
+        tune = car_params.lateralTuning
+        if tune.which() == 'pid':
+          if car_name != MOCK.MOCK:
+            assert not math.isnan(tune.pid.kf) and tune.pid.kf > 0
+            assert len(tune.pid.kpV) > 0 and len(tune.pid.kpV) == len(tune.pid.kpBP)
+            assert len(tune.pid.kiV) > 0 and len(tune.pid.kiV) == len(tune.pid.kiBP)
+
+        elif tune.which() == 'torque':
+          assert not math.isnan(tune.torque.kf) and tune.torque.kf > 0
+          assert not math.isnan(tune.torque.friction) and tune.torque.friction > 0
+
+      # Run car interface
+      # TODO: use hypothesis to generate random messages
+      now_nanos = 0
+      CC = structs.CarControl().as_reader()
+      for _ in range(10):
+        car_interface.update([])
+        car_interface.apply(CC, now_nanos)
+        now_nanos += DT_CTRL * 1e9  # 10 ms
+
+      CC = structs.CarControl()
+      CC.enabled = True
+      CC.latActive = True
+      CC.longActive = True
+      CC = CC.as_reader()
+      for _ in range(10):
+        car_interface.update([])
+        car_interface.apply(CC, now_nanos)
+        now_nanos += DT_CTRL * 1e9  # 10ms
+
+      # Test radar interface
+      radar_interface = car_interface.RadarInterface(car_params)
+      assert radar_interface
+
+      # Run radar interface once
+      radar_interface.update([])
+      if not car_params.radarUnavailable and radar_interface.rcp is not None and \
+         hasattr(radar_interface, '_update') and hasattr(radar_interface, 'trigger_msg'):
+        radar_interface._update([radar_interface.trigger_msg])
+
+      # Test radar fault
+      if not car_params.radarUnavailable and radar_interface.rcp is not None:
+        cans = [(0, [CanData(0, b'', 0) for _ in range(5)])]
+        rr = radar_interface.update(cans)
+        assert rr is None or len(rr.errors) > 0
+
+    from opendbc.car.values import PLATFORMS
+    for car_name in sorted(PLATFORMS):
+      with subtests.test(car_name=car_name):
+        run_car_interface_test(car_name=car_name)
 
   def test_interface_attrs(self):
     """Asserts basic behavior of interface attribute getter"""
+    from opendbc.car.interfaces import get_interface_attr
     num_brands = len(get_interface_attr('CAR'))
     assert num_brands >= 12
 

opendbc/car/tests/test_docs.py

@@ -1,16 +1,13 @@
 from collections import defaultdict
 import pytest
 
-from opendbc.car.car_helpers import interfaces
-from opendbc.car.docs import get_all_car_docs
 from opendbc.car.docs_definitions import Cable, Column, PartType, Star, SupportType
-from opendbc.car.honda.values import CAR as HONDA
-from opendbc.car.values import PLATFORMS
 
 
 class TestCarDocs:
   @classmethod
   def setup_class(cls):
+    from opendbc.car.docs import get_all_car_docs
     cls.all_cars = get_all_car_docs()
 
   def test_duplicate_years(self, subtests):
@@ -26,6 +23,8 @@ def test_duplicate_years(self, subtests):
           make_model_years[make_model].append(year)
 
   def test_missing_car_docs(self, subtests):
+    from opendbc.car.values import PLATFORMS
+    from opendbc.car.car_helpers import interfaces
     all_car_docs_platforms = [name for name, config in PLATFORMS.items()]
     for platform in sorted(interfaces.keys()):
       with subtests.test(platform=platform):
@@ -48,6 +47,7 @@ def test_naming_conventions(self, subtests):
             assert "RAV4" in car.model, "Use correct capitalization"
 
   def test_torque_star(self, subtests):
+    from opendbc.car.honda.values import CAR as HONDA
     # Asserts brand-specific assumptions around steering torque star
     for car in self.all_cars:
       with subtests.test(car=car.name):