approval-utilities 13.0.0__tar.gz → 14.1.0__tar.gz

{approval_utilities-13.0.0/approval_utilities.egg-info → approval_utilities-14.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: approval_utilities
-Version: 13.0.0
+Version: 14.1.0
 Summary: Utilities for your production code that work well with approvaltests
 Home-page: https://github.com/approvals/ApprovalTests.Python
 Author: ApprovalTests Contributors

{approval_utilities-13.0.0 → approval_utilities-14.1.0}/approval_utilities/utils.py

@@ -1,8 +1,11 @@
 import inspect
 import json
 import os
+
 from copy import deepcopy
 
+from typing import Callable, Dict, TypeVar
+
 
 def get_adjacent_file(name: str) -> str:
     calling_file = inspect.stack(1)[1][1]
@@ -53,12 +56,17 @@ def is_windows_os() -> bool:
 
 
 def create_empty_file(file_path: str) -> None:
-    import empty_files.empty_files
+    try:
+        import empty_files.empty_files
 
-    empty_files.empty_files.create_empty_file(file_path)
+        empty_files.empty_files.create_empty_file(file_path)
+    except ImportError as e:
+        print("Error importing empty_files", e)
+        raise
 
 
 def ensure_file_exists(approved_path: str) -> None:
+    print("approved_path check", approved_path)
     if not os.path.isfile(approved_path):
         create_empty_file(approved_path)
 
@@ -76,3 +84,11 @@ def print_grid(width, height, cell_print_func):
             result += cell_print_func(x, y)
         result += "\n"
     return result
+
+
+_V = TypeVar("_V")
+_K = TypeVar("_K")
+
+
+def filter_values(filter: Callable[[_V], bool], a_dict: Dict[_K, _V]) -> Dict[_K, _V]:
+    return {k: v for k, v in a_dict.items() if filter(v)}

{approval_utilities-13.0.0 → approval_utilities-14.1.0/approval_utilities.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: approval_utilities
-Version: 13.0.0
+Version: 14.1.0
 Summary: Utilities for your production code that work well with approvaltests
 Home-page: https://github.com/approvals/ApprovalTests.Python
 Author: ApprovalTests Contributors

{approval_utilities-13.0.0 → approval_utilities-14.1.0}/approval_utilities.egg-info/SOURCES.txt

@@ -42,11 +42,14 @@ approval_utilities/utilities/persistence/__init__.py
 approval_utilities/utilities/persistence/loader.py
 approval_utilities/utilities/persistence/saver.py
 tests/test_asserts.py
+tests/test_build.py
 tests/test_combinations.py
+tests/test_compare_file_lists.py
 tests/test_custom_printers.py
 tests/test_example_numpy.py
 tests/test_exception_utils.py
 tests/test_fileapprover.py
+tests/test_find_stale_approved_files.py
 tests/test_inline_approvals.py
 tests/test_list.py
 tests/test_multiline_string_utils.py
@@ -60,4 +63,5 @@ tests/test_simple_logger.py
 tests/test_split_code.py
 tests/test_verify.py
 tests/test_verify_all.py
+tests/test_verify_argument_parser.py
 tests/test_writer.py

approval_utilities-14.1.0/tests/test_build.py

@@ -0,0 +1,33 @@
+import os
+import ast
+
+
+def test_no_imports_from_build_directory():
+    # Make sure no file imports from build
+    root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+    for dirpath, dirnames, filenames in os.walk(root_dir):
+        # Exclude directories that start with '.'
+        dirnames[:] = [d for d in dirnames if not d.startswith(".") and d != "build"]
+        # also exclude venv
+        dirnames[:] = [d for d in dirnames if not d.startswith("venv")]
+        for filename in filenames:
+            # Skip files that start with '.' and non-Python files
+            if filename.startswith(".") or not filename.endswith(".py"):
+                continue
+            file_path = os.path.join(dirpath, filename)
+            with open(file_path, "r", encoding="utf-8") as file:
+                source = file.read()
+            try:
+                tree = ast.parse(source, filename=file_path)
+            except SyntaxError:
+                continue  # Skip files with syntax errors
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        if alias.name == "build" or alias.name.startswith("build."):
+                            assert False, f"{file_path} imports 'build'"
+                elif isinstance(node, ast.ImportFrom):
+                    if node.module == "build" or (
+                        node.module and node.module.startswith("build.")
+                    ):
+                        assert False, f"{file_path} imports from 'build'"

approval_utilities-14.1.0/tests/test_compare_file_lists.py

@@ -0,0 +1,25 @@
+def compare_log_and_file_system(log_file_names, fs_file_names):
+    return [file for file in fs_file_names if file not in log_file_names]
+
+
+def test_returns_empty_list_for_two_empty_lists():
+    log_file_names = []
+    fs_file_names = []
+    assert compare_log_and_file_system(log_file_names, fs_file_names) == []
+
+
+def test_returns_empty_list_for_identical_lists():
+    log_file_names = ["a", "b", "c"]
+    fs_file_names = ["a", "b", "c"]
+    assert compare_log_and_file_system(log_file_names, fs_file_names) == []
+
+
+def test_returns_items_only_in_fs():
+    log_file_names = ["a", "b", "c"]
+    fs_file_names = ["a", "b", "c", "d", "e"]
+    assert compare_log_and_file_system(log_file_names, fs_file_names) == ["d", "e"]
+
+
+# Future tests
+# 1 - fs:[a,b,c], log:[a,b,c] => []
+# 2 - fs:[a,b,c,d], log:[a,b,c] => [d]

{approval_utilities-13.0.0 → approval_utilities-14.1.0}/tests/test_fileapprover.py

@@ -8,6 +8,7 @@ from approvaltests.reporters.generic_diff_reporter_factory import (
 )
 from approvaltests.reporters.testing_reporter import ReporterForTesting
 from approvaltests.string_writer import StringWriter
+from approvaltests.approved_file_log import ApprovedFilesLog
 
 
 class FileApproverTests(unittest.TestCase):
@@ -52,6 +53,22 @@ class FileApproverTests(unittest.TestCase):
         error = FileApprover.verify(namer, writer, reporter, Options().comparator)
         self.assertEqual(None, error)
 
+    def test_approved_file_is_logged(self):
+        name = approvals.get_default_namer().get_approved_filename()
+        log = ApprovedFilesLog.get_approved_files_log()
+        log_lines = log.read_text().split("\n")
+        name1 = name.replace(".txt", ".txt1")
+        name2 = name.replace(".txt", ".txt2")
 
-if __name__ == "__main__":
-    unittest.main()
+        # check log is cleared
+        self.assertNotIn(name1, log_lines)
+        self.assertNotIn(name2, log_lines)
+
+        # touch approved file
+        verify("a", options=Options().for_file.with_extension(".txt1"))
+        verify("a", options=Options().for_file.with_extension(".txt2"))
+
+        # assert that the approved file is logged
+        log_lines = log.read_text().split("\n")
+        self.assertIn(name1, log_lines)
+        self.assertIn(name2, log_lines)

approval_utilities-14.1.0/tests/test_find_stale_approved_files.py

@@ -0,0 +1,132 @@
+import os
+import sys
+import tempfile
+import subprocess
+
+from approvaltests import Options, verify_argument_parser
+from approvaltests.utilities.logger.simple_logger_approvals import verify_simple_logger
+from approval_utilities.utilities.logger.simple_logger import SimpleLogger
+from tests.find_stale_approved_files import create_argument_parser
+from approvaltests.scrubbers import create_regex_scrubber
+
+
+# Create a temporary sandbox directory and log file
+def create_sandbox(approved_files, log_entries, nested=False):
+    sandbox_dir = tempfile.TemporaryDirectory()
+    log_file_path = os.path.join(sandbox_dir.name, "approvedfiles.log")
+
+    # Create approved files in the sandbox
+    for file_name in approved_files:
+        if nested:
+            nested_dir = os.path.join(sandbox_dir.name, "nested")
+            os.makedirs(nested_dir, exist_ok=True)
+            open(os.path.join(nested_dir, file_name), "w").close()
+        else:
+            open(os.path.join(sandbox_dir.name, file_name), "w").close()
+
+    # Write the log entries to the log file
+    with open(log_file_path, "w") as log_file:
+        for entry in log_entries:
+            if nested:
+                log_file.write(os.path.join(sandbox_dir.name, "nested", entry) + "\n")
+            else:
+                log_file.write(os.path.join(sandbox_dir.name, entry) + "\n")
+
+    return sandbox_dir, log_file_path
+
+
+# Execute the comparison script
+def execute_script(directory, log_file):
+
+    script = "find_stale_approved_files.py"
+    dirname = os.path.dirname(__file__)
+    full_script = os.path.join(dirname, script)
+    print(f"Executing script: {full_script=}")
+    result = subprocess.run(
+        [sys.executable, full_script, directory, log_file],
+        capture_output=True,
+        text=True,
+    )
+    output = result.stdout
+    SimpleLogger.message(output)
+
+
+def test_create_argument_parser():
+    verify_argument_parser(create_argument_parser())
+
+
+def test_find_stale_approved_files():
+    scrubber = create_regex_scrubber(r".+(?=file\d\.)", "")
+    with verify_simple_logger(options=Options().with_scrubber(scrubber)):
+        # Test Scenario 1: All approved files are in the log
+        SimpleLogger.message("Test Scenario 1: All approved files are in the log")
+        approved_files_1 = [
+            "file1.approved.txt",
+            "file2.approved.doc",
+            "file3.approved.csv",
+        ]
+        log_entries_1 = approved_files_1
+        verify_files(approved_files_1, log_entries_1)
+
+        # Test Scenario 2: Approved files that are not in the log
+        SimpleLogger.message("Test Scenario 2: Approved files that are not in the log")
+        approved_files_2 = [
+            "file1.approved.txt",
+            "file2.approved.doc",
+            "file3.approved.csv",
+            "file4.approved.md",
+        ]
+        log_entries_2 = approved_files_2[
+            :-1
+        ]  # Exclude 'file4.approved.md' from the log
+        verify_files(approved_files_2, log_entries_2)
+
+        # Test Scenario 3: Log contains files that are not in the directory
+        SimpleLogger.message(
+            "Test Scenario 3: Log contains files that are not in the directory"
+        )
+        approved_files_3 = ["file1.approved.txt", "file2.approved.doc"]
+        log_entries_3 = approved_files_3 + [
+            "file3.approved.csv"
+        ]  # 'file3.approved.csv' is in the log but not in the directory
+        verify_files(approved_files_3, log_entries_3)
+
+        # Test Scenario 4: No approved files in the directory
+        SimpleLogger.message("Test Scenario 4: No approved files in the directory")
+        verify_files([], ["file1.approved.txt", "file2.approved.doc"])
+
+        # Test Scenario 5: Directory has files but none are in the log
+        SimpleLogger.message(
+            "Test Scenario 5: Directory has files but none are in the log"
+        )
+        verify_files(["file1.approved.txt", "file2.approved.doc"], [])
+
+        # Test Scenario 6: Nested folders with approved files
+        SimpleLogger.message("Test Scenario 6: Nested folders with approved files")
+        approved_files_6 = ["file1.approved.txt", "file2.approved.doc"]
+        verify_files(approved_files_6, approved_files_6, nested=True)
+
+        # Test Scenario 7: Files that do not match the naming convention
+        SimpleLogger.message(
+            "Test Scenario 7: Files that do not match the naming convention"
+        )
+        approved_files_7 = ["file1.txt", "file2.doc", "file3.csv"]
+        verify_files(approved_files_7, approved_files_7)
+
+        SimpleLogger.message(
+            "Test Scenario 8: Log contains files that are not in the directory"
+        )
+        approved_files = ["custom_name_1.txt"]
+        log_entries = approved_files + ["custom_name_2.txt"]
+        verify_files(approved_files, log_entries)
+
+
+def verify_files(approved_files, log_entries, nested=False):
+    SimpleLogger.variable("Approved Files", approved_files)
+    SimpleLogger.variable("Log Entries", log_entries)
+
+    sandbox_dir, log_file_path = create_sandbox(
+        approved_files, log_entries, nested=nested
+    )
+    execute_script(sandbox_dir.name, log_file_path)
+    sandbox_dir.cleanup()

{approval_utilities-13.0.0 → approval_utilities-14.1.0}/tests/test_inline_approvals.py

@@ -16,7 +16,7 @@ from approvaltests import (
 from approvaltests.inline.inline_options import InlineOptions
 from approvaltests.inline.parse_docstring import parse_docstring
 from approvaltests.reporters.report_quietly import ReportQuietly
-from build.lib.approvaltests.reporters.report_with_beyond_compare import (
+from approvaltests.reporters.report_with_beyond_compare import (
     ReportWithPycharm,
     ReportWithBeyondCompare,
 )

{approval_utilities-13.0.0 → approval_utilities-14.1.0}/tests/test_options.py

@@ -8,7 +8,7 @@ from approvaltests import (
     combination_approvals,
 )
 from approvaltests.core.options import Options
-from approvaltests.mrjob import mrjob_approvals
+from approvaltests.integrations.mrjob import mrjob_approvals
 from approvaltests.reporters import ReportByCreatingDiffFile, MultiReporter
 from approvaltests.reporters.report_with_beyond_compare import ReportWithPycharm
 from approvaltests.utilities import command_line_approvals

approval_utilities-14.1.0/tests/test_verify_argument_parser.py

@@ -0,0 +1,16 @@
+import argparse
+import os
+
+from approvaltests import verify_argument_parser
+from tests.find_stale_approved_files import create_argument_parser
+
+
+def test_argument_parser():
+    parser = argparse.ArgumentParser(
+        prog="my_program.py",
+        description="My Description",
+    )
+    parser.add_argument("1st_argument", help="1st argument help text")
+    parser.add_argument("--optional_argument", help="An Optional Argument help text")
+    parser.add_argument("long_argument", help=f"{'Very' * 100} Long message")
+    verify_argument_parser(parser)

approval_utilities-14.1.0/version.py

@@ -0,0 +1 @@
+version_number = "v14.1.0"

approval_utilities-13.0.0/version.py

@@ -1 +0,0 @@
-version_number = "v13.0.0"