refactor test_extension_matching tests to use explicit extensions

can/io/logger.py

@@ -97,7 +97,10 @@ def __new__(  # type: ignore
             suffix, file_or_filename = Logger.compress(filename)
 
         try:
-            return Logger.message_writers[suffix](file_or_filename, *args, **kwargs)
+            LoggerType = Logger.message_writers[suffix]
+            if LoggerType is None:
+                raise (ValueError(f'failed to import logger for extension "{suffix}"'))
+            return LoggerType(file_or_filename, *args, **kwargs)
         except KeyError:
             raise ValueError(
                 f'No write support for this unknown log format "{suffix}"'

can/io/mf4.py

@@ -22,10 +22,7 @@
     from asammdf.blocks.v4_constants import BUS_TYPE_CAN, SOURCE_BUS
     import numpy as np
 
-    ASAMMDF_AVAILABLE = True
-
 except ImportError as error:
-    ASAMMDF_AVAILABLE = False
     raise error
 
 

test/logformats_test.py

@@ -36,34 +36,50 @@
 
 
 class ReaderWriterExtensionTest(unittest.TestCase):
-    message_writers_and_readers = {}
-    for suffix, writer in can.Logger.message_writers.items():
-        message_writers_and_readers[suffix] = (
-            writer,
-            can.LogReader.message_readers.get(suffix),
-        )
+    def _get_suffix_case_variants(self, suffix):
+        return [
+            suffix.upper(),
+            suffix.lower(),
+            f"can.msg.ext{suffix}",
+            "".join([c.upper() if i % 2 else c for i, c in enumerate(suffix)]),
+        ]
 
-    def test_extension_matching(self):
-        for suffix, (writer, reader) in self.message_writers_and_readers.items():
-            suffix_variants = [
-                suffix.upper(),
-                suffix.lower(),
-                f"can.msg.ext{suffix}",
-                "".join([c.upper() if i % 2 else c for i, c in enumerate(suffix)]),
-            ]
-            for suffix_variant in suffix_variants:
-                tmp_file = tempfile.NamedTemporaryFile(
-                    suffix=suffix_variant, delete=False
-                )
-                tmp_file.close()
-                try:
+    def _test_extension(self, suffix):
+        WriterType = can.Logger.message_writers.get(suffix)
+        ReaderType = can.LogReader.message_readers.get(suffix)
+        for suffix_variant in self._get_suffix_case_variants(suffix):
+            tmp_file = tempfile.NamedTemporaryFile(suffix=suffix_variant, delete=False)
+            tmp_file.close()
+            try:
+                if WriterType:
                     with can.Logger(tmp_file.name) as logger:
-                        assert type(logger) == writer
-                    if reader is not None:
-                        with can.LogReader(tmp_file.name) as player:
-                            assert type(player) == reader
-                finally:
-                    os.remove(tmp_file.name)
+                        assert type(logger) == WriterType
+                if ReaderType:
+                    with can.LogReader(tmp_file.name) as player:
+                        assert type(player) == ReaderType
+            finally:
+                os.remove(tmp_file.name)
+
+    def test_extension_matching_asc(self):
+        self._test_extension(".asc")
+
+    def test_extension_matching_blf(self):
+        self._test_extension(".blf")
+
+    def test_extension_matching_csv(self):
+        self._test_extension(".csv")
+
+    def test_extension_matching_db(self):
+        self._test_extension(".db")
+
+    def test_extension_matching_log(self):
+        self._test_extension(".log")
+
+    def test_extension_matching_txt(self):
+        self._test_extension(".txt")
+
+    def test_extension_matching_mf4(self):
+        self._test_extension(".mf4")
 
 
 class ReaderWriterTest(unittest.TestCase, ComparingMessagesTestCase, metaclass=ABCMeta):