[CI] Updates file hygiene in tests (autoflake)

Author: parthacharyaaaaa

tests/__init__.py

@@ -1 +1 @@
-'''Testing module for locstat'''
+"""Testing module for locstat"""

tests/constants.py

@@ -1,7 +1,6 @@
 from typing import Final
 
-__all__ = ("UNIX_NEWLINE",
-           "WIN_NEWLINE")
+__all__ = ("UNIX_NEWLINE", "WIN_NEWLINE")
 
 UNIX_NEWLINE: Final[str] = "\n"
-WIN_NEWLINE: Final[str] = "\r\n"
+WIN_NEWLINE: Final[str] = "\r\n"

tests/fixtures.py

@@ -5,6 +5,7 @@
 from locstat.data_structures.verbosity import Verbosity
 from locstat.data_structures.parse_modes import ParseMode
 
+
 @dataclass
 class MockConfig:
     verbosity: Verbosity = field(default=Verbosity.BARE)
@@ -14,14 +15,17 @@ class MockConfig:
 
     @property
     def configurable(self) -> frozenset[str]:
-        return frozenset(["verbosity", "minimum_characters",
-                          "max_depth", "parsing_mode"])
+        return frozenset(
+            ["verbosity", "minimum_characters", "max_depth", "parsing_mode"]
+        )
+
 
 @pytest.fixture
 def mock_config() -> MockConfig:
     return MockConfig()
 
+
 @pytest.fixture
 def mock_dir(tmp_path_factory):
     path = tmp_path_factory.mktemp("_temp_dir")
-    return path
+    return path

tests/integrity/__init__.py

@@ -1 +1 @@
-'''Integrity tests'''
+"""Integrity tests"""

tests/integrity/test_parsing_modes_consistency.py

@@ -8,6 +8,7 @@
 from locstat.utilities.core import derive_file_parser
 from locstat.data_structures.parse_modes import ParseMode
 
+
 def _populate_directory(directory: Path) -> None:
     directory.mkdir(parents=True, exist_ok=True)
 
@@ -19,9 +20,7 @@ def _populate_directory(directory: Path) -> None:
     for d in (src, utils, tests, data):
         d.mkdir(parents=True, exist_ok=True)
 
-    (src / "main.py").write_text(
-        textwrap.dedent(
-            """
+    (src / "main.py").write_text(textwrap.dedent("""
             \"\"\"
             Entry point for the application.
             \"\"\"
@@ -38,14 +37,9 @@ def main():
 
             if __name__ == "__main__":
                 main()
-            """
-        ).strip()
-        + "\n"
-    )
+            """).strip() + "\n")
 
-    (utils / "math_utils.py").write_text(
-        textwrap.dedent(
-            """
+    (utils / "math_utils.py").write_text(textwrap.dedent("""
             \"\"\"
             Utility functions for math operations.
             \"\"\"
@@ -63,14 +57,9 @@ def add(a: int, b: int) -> int:
                     The sum of a and b
                 \"\"\"
                 return a + b
-            """
-        ).strip()
-        + "\n"
-    )
+            """).strip() + "\n")
 
-    (tests / "test_math_utils.py").write_text(
-        textwrap.dedent(
-            """
+    (tests / "test_math_utils.py").write_text(textwrap.dedent("""
             import pytest
 
             from src.utils.math_utils import add
@@ -83,14 +72,9 @@ def test_add_basic():
 
             def test_add_negative_numbers():
                 assert add(-1, -2) == -3
-            """
-        ).strip()
-        + "\n"
-    )
+            """).strip() + "\n")
 
-    (directory / "README.md").write_text(
-        textwrap.dedent(
-            """
+    (directory / "README.md").write_text(textwrap.dedent("""
             # Mock Project
 
             This is a fake project structure used for testing filesystem behavior.
@@ -99,10 +83,7 @@ def test_add_negative_numbers():
             - Python code
             - Nested directories
             - Symlinks
-            """
-        ).strip()
-        + "\n"
-    )
+            """).strip() + "\n")
 
     (data / "sample.txt").write_text(
         "This is a sample data file.\n\nIt has multiple lines.\n"
@@ -116,23 +97,31 @@ def test_add_negative_numbers():
     except (OSError, NotImplementedError):
         pass
 
+
 def test_parse_mode_consistency(mock_dir, mock_config):
     _populate_directory(mock_dir)
 
-    object.__setattr__(mock_config, "symbol_mapping", {"py" : (b"#", None, None)})
+    object.__setattr__(mock_config, "symbol_mapping", {"py": (b"#", None, None)})
 
     outputs: dict[ParseMode, array.array] = {}
     for parse_mode in ParseMode:
-        result: array.array = array.array("L", (0,0))
+        result: array.array = array.array("L", (0, 0))
         mock_config.parsing_mode = parse_mode
-        parse_directory(os.scandir(mock_dir),
-                        mock_config,
-                        result,
-                        -1,
-                        derive_file_parser(parse_mode))
+        parse_directory(
+            os.scandir(mock_dir),
+            mock_config,
+            result,
+            -1,
+            derive_file_parser(parse_mode),
+        )
         outputs[parse_mode] = result
 
-    assert len(set(tuple(o) for o in outputs.values())) == 1, \
-    " ".join(("Parsing modes produce different outputs",
-              "\n".join(f"{mode}: Total={total}, LOC={loc}"
-                       for mode, (total, loc) in outputs.items())))
+    assert len(set(tuple(o) for o in outputs.values())) == 1, " ".join(
+        (
+            "Parsing modes produce different outputs",
+            "\n".join(
+                f"{mode}: Total={total}, LOC={loc}"
+                for mode, (total, loc) in outputs.items()
+            ),
+        )
+    )

tests/unit/test_argument_parser.py

@@ -1,17 +1,19 @@
-'''Unit tests for CLI argument parser'''
+"""Unit tests for CLI argument parser"""
+
 import argparse
 
 from locstat.argparser import initialize_parser, parse_arguments
 
 from tests.fixtures import mock_config, mock_dir
 
+
 def test_exclusive_groups(mock_config, mock_dir) -> None:
     parser: argparse.ArgumentParser = initialize_parser(mock_config)
 
     illegal_combinations: tuple[str, ...] = (
         "-it py -xt js",
         "-if foo.py -xf bar.py",
-        "-id foo -xd bar"
+        "-id foo -xd bar",
     )
 
     base_args: str = f"-d {mock_dir}"
@@ -20,11 +22,13 @@ def test_exclusive_groups(mock_config, mock_dir) -> None:
         failed: bool = False
         try:
             parse_arguments(" ".join((base_args, combination)).split(), parser)
-        except SystemExit as se:
+        except SystemExit:
             failed = True
         finally:
-            assert failed, \
-            f"Illegal argument combination '{combination}' accepted by argument parser"
+            assert (
+                failed
+            ), f"Illegal argument combination '{combination}' accepted by argument parser"
+
 
 def test_allowed_combinations(mock_config, mock_dir):
     parser: argparse.ArgumentParser = initialize_parser(mock_config)
@@ -35,7 +39,7 @@ def test_allowed_combinations(mock_config, mock_dir):
         "-if foo.py bar.py",
         "-xf foo.py bar.py",
         "-id foo bar",
-        "-xd foo bar"
+        "-xd foo bar",
     )
 
     base_args: str = f"-d {mock_dir}"
@@ -46,32 +50,37 @@ def test_allowed_combinations(mock_config, mock_dir):
         except SystemExit as e:
             e.add_note(f"Original argument: {base_args + arg}")
             raise e
-        
+
+
 def test_target_existence(mock_config, mock_dir):
     parser: argparse.ArgumentParser = initialize_parser(mock_config)
 
     mock_subdir = mock_dir / "_temp_subdir"
     mock_file = mock_subdir / "_temp_file.py"
 
-    arg_mapping: dict[str, type[BaseException]] = {f"-f {mock_file}" : SystemExit,
-                                         f"-d {mock_subdir}" : SystemExit}
+    arg_mapping: dict[str, type[BaseException]] = {
+        f"-f {mock_file}": SystemExit,
+        f"-d {mock_subdir}": SystemExit,
+    }
 
     for arg, expected_exception in arg_mapping.items():
         failed: bool = False
         arg_sequence: list[str] = arg.split()
         try:
             parse_arguments(arg_sequence, parser)
         except SystemExit as e:
-            assert isinstance(e, expected_exception), \
-                " ".join((f"Non-existing target {arg_sequence[-1]} rejected with unexpected error",
-                          f"Expected: {expected_exception}",
-                          f"Raised: {e}"))
+            assert isinstance(e, expected_exception), " ".join(
+                (
+                    f"Non-existing target {arg_sequence[-1]} rejected with unexpected error",
+                    f"Expected: {expected_exception}",
+                    f"Raised: {e}",
+                )
+            )
             failed = True
-        assert failed, \
-        f"Non-existing target {arg_sequence[-1]} accepted"
+        assert failed, f"Non-existing target {arg_sequence[-1]} accepted"
 
     mock_subdir.mkdir()
     mock_file.touch()
 
     for arg in arg_mapping:
-        parse_arguments(arg.split(), parser)
+        parse_arguments(arg.split(), parser)