Merge pull request #97 from dbatten5/bump-version

Bump version

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "maison"
-version = "1.3.0"
+version = "1.4.0"
 description = "Maison"
 authors = ["Dom Batten <[email protected]>"]
 license = "MIT"

src/maison/utils.py

@@ -41,25 +41,24 @@ def get_file_path(
     if filename_path.is_absolute() and filename_path.is_file():
         return filename_path
 
-    for path in _generate_search_paths(starting_path=starting_path):
+    start = starting_path or Path.cwd()
+
+    for path in _generate_search_paths(starting_path=start):
         if path_contains_file(path=path, filename=filename):
             return path / filename
 
     return None
 
 
-def _generate_search_paths(
-    starting_path: Optional[Path] = None,
-) -> Generator[Path, None, None]:
-    """Generate paths from either a starting path or `Path.cwd()`.
+def _generate_search_paths(starting_path: Path) -> Generator[Path, None, None]:
+    """Generate paths from a starting path and traversing up the tree.
 
     Args:
-        starting_path: an optional starting path to start yielding search paths
+        starting_path: a starting path to start yielding search paths
 
     Yields:
-        a path
+        a path from the tree
     """
-    starting_path = starting_path or Path.cwd()
     for path in [starting_path, *starting_path.parents]:
         yield path
 

tests/unit/test_utils.py

@@ -122,44 +122,48 @@ def test_absolute_path_not_exist(self) -> None:
         assert result is None
 
 
-@mark.parametrize(
-    "a,b,expected",
-    [
-        param(
-            {1: 2, 3: 4},
-            {3: 5, 6: 7},
-            {1: 2, 3: 5, 6: 7},
-            id="simple",
-        ),
-        param(
-            {1: 2, 3: {4: 5, 6: 7}},
-            {3: {6: 8, 9: 10}, 11: 12},
-            {1: 2, 3: {4: 5, 6: 8, 9: 10}, 11: 12},
-            id="nested",
-        ),
-    ],
-)
-def test_deep_merge(
-    a: Dict[Any, Any],
-    b: Dict[Any, Any],
-    expected: Dict[Any, Any],
-) -> None:
-    """
-    Given two dictionaries `a` and `b`,
-    when the `deep_merge` function is invoked with `a` and `b` as arguments,
-    Test that the returned value is as expected.
-    """
-    assert deep_merge(a, b) == expected
-    assert a == expected
-
-
-def test_deep_merge_dict_into_scalar() -> None:
-    """
-    Given two incompatible dictionaries `a` and `b`,
-    when the `deep_merge` function is invoked with `a` and `b` as arguments,
-    Test that a RuntimeError is raised.
-    """
-    a = {1: 2, 2: 5}
-    b = {1: {3: 4}}
-    with raises(RuntimeError):
-        deep_merge(a, b)
+class TestDeepMerge:
+    """Tests for the `deep_merge` function."""
+
+    @mark.parametrize(
+        "a,b,expected",
+        [
+            param(
+                {1: 2, 3: 4},
+                {3: 5, 6: 7},
+                {1: 2, 3: 5, 6: 7},
+                id="simple",
+            ),
+            param(
+                {1: 2, 3: {4: 5, 6: 7}},
+                {3: {6: 8, 9: 10}, 11: 12},
+                {1: 2, 3: {4: 5, 6: 8, 9: 10}, 11: 12},
+                id="nested",
+            ),
+        ],
+    )
+    def test_success(
+        self,
+        a: Dict[Any, Any],
+        b: Dict[Any, Any],
+        expected: Dict[Any, Any],
+    ) -> None:
+        """
+        Given two dictionaries `a` and `b`,
+        When the `deep_merge` function is invoked with `a` and `b` as arguments,
+        Then the returned value is as expected
+        """
+        assert deep_merge(a, b) == expected
+        assert a == expected
+
+    def test_incompatible_dicts(self) -> None:
+        """
+        Given two incompatible dictionaries `a` and `b`,
+        When the `deep_merge` function is invoked with `a` and `b` as arguments,
+        Then a RuntimeError is raised
+        """
+        dict_a = {1: 2, 2: 5}
+        dict_b = {1: {3: 4}}
+
+        with raises(RuntimeError):
+            deep_merge(dict_a, dict_b)