feat: dev

Author: wislertt

Makefile

@@ -39,7 +39,7 @@ lint:
 
 
 test:
-	poetry run pytest leetcode/ \
+	poetry run pytest leetcode/ tests/ \
 		-v --cov=leetcode --cov=leetcode_py \
 		--cov-report=term-missing \
 		--cov-report=xml \

README.md

@@ -7,7 +7,7 @@
 [![tests](https://img.shields.io/github/actions/workflow/status/wisarootl/leetcode-py/ci-test.yml?branch=main&label=tests&logo=github)](https://github.com/wisarootl/zerv/actions/workflows/ci-test.yml)
 [![release](https://img.shields.io/github/actions/workflow/status/wisarootl/leetcode-py/cd.yml?branch=main&label=release&logo=github)](https://github.com/wisarootl/zerv/actions/workflows/cd.yml)
 
-Premium LeetCode practice environment with modern Python tooling, beautiful tree visualizations, and comprehensive testing.
+Premium LeetCode practice repository with Python solutions, algorithm templates, data structure visualizations, and automated testing. Perfect for coding interview preparation, competitive programming, and mastering algorithms with Blind 75, Grind 75, and NeetCode 150 problems.
 
 ## 📋 Prerequisites
 

pyproject.toml

@@ -69,8 +69,8 @@ disable_error_code = ["return", "no-redef"]
 exclude = [".templates"]
 
 [tool.pytest.ini_options]
-testpaths = ["leetcode"]
-python_files = ["tests.py"]
+testpaths = ["leetcode", "tests"]
+python_files = ["tests.py", "test_*.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]
 addopts = "-v --tb=short"

tests/__init__.py

@@ -0,0 +1 @@
+# Tests package

tests/test_list_node.py

@@ -0,0 +1,105 @@
+import pytest
+
+from leetcode_py.list_node import ListNode
+
+
+class TestListNode:
+    @pytest.mark.parametrize(
+        "val,expected_val,expected_next",
+        [
+            (None, 0, None),  # default
+            (5, 5, None),  # with value
+        ],
+    )
+    def test_init(self, val, expected_val, expected_next):
+        node = ListNode() if val is None else ListNode(val)
+        assert node.val == expected_val
+        assert node.next == expected_next
+
+    def test_init_with_next(self):
+        next_node = ListNode(2)
+        node = ListNode(1, next_node)
+        assert node.val == 1
+        assert node.next == next_node
+
+    @pytest.mark.parametrize(
+        "input_list,expected_result",
+        [
+            ([], None),
+            ([1], "single_node"),
+            ([1, 2, 3], "multiple_nodes"),
+        ],
+    )
+    def test_from_list(self, input_list, expected_result):
+        result = ListNode.from_list(input_list)
+
+        if expected_result is None:
+            assert result is None
+        elif expected_result == "single_node":
+            assert result is not None
+            assert result.val == 1
+            assert result.next is None
+        elif expected_result == "multiple_nodes":
+            assert result is not None
+            assert result.val == 1
+            assert result.next is not None
+            assert result.next.val == 2
+            assert result.next.next is not None
+            assert result.next.next.val == 3
+            assert result.next.next.next is None
+
+    @pytest.mark.parametrize(
+        "input_list,expected_output",
+        [
+            ([1], [1]),
+            ([1, 2, 3], [1, 2, 3]),
+        ],
+    )
+    def test_to_list(self, input_list, expected_output):
+        node = ListNode.from_list(input_list)
+        assert node is not None
+        assert node.to_list() == expected_output
+
+    @pytest.mark.parametrize(
+        "input_list,expected_str,expected_repr",
+        [
+            ([1, 2, 3], "1 -> 2 -> 3", "ListNode([1, 2, 3])"),
+        ],
+    )
+    def test_string_representations(self, input_list, expected_str, expected_repr):
+        node = ListNode.from_list(input_list)
+        assert node is not None
+        assert str(node) == expected_str
+        assert repr(node) == expected_repr
+        assert node._repr_html_() == expected_str
+
+    @pytest.mark.parametrize(
+        "list1,list2,should_equal",
+        [
+            ([1, 2, 3], [1, 2, 3], True),
+            ([1, 2, 3], [1, 2, 4], False),
+        ],
+    )
+    def test_equality(self, list1, list2, should_equal):
+        node1 = ListNode.from_list(list1)
+        node2 = ListNode.from_list(list2)
+        assert (node1 == node2) == should_equal
+
+    @pytest.mark.parametrize("other_value", [[1], "1"])
+    def test_equality_different_types(self, other_value):
+        node = ListNode(1)
+        assert node != other_value
+
+    @pytest.mark.parametrize(
+        "test_list",
+        [
+            [1, 2, 3, 4, 5],
+            [1],
+            [10, 20, 30],
+        ],
+    )
+    def test_roundtrip_conversion(self, test_list):
+        node = ListNode.from_list(test_list)
+        assert node is not None
+        result = node.to_list()
+        assert result == test_list

tests/test_test_utils.py

@@ -0,0 +1,71 @@
+from unittest.mock import patch
+
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+
+class TestLoggedTest:
+    def test_logged_test_decorator_success(self):
+        @logged_test
+        def sample_test():
+            return "success"
+
+        result = sample_test()
+        assert result == "success"
+
+    def test_logged_test_decorator_failure(self):
+        @logged_test
+        def failing_test():
+            raise ValueError("test error")
+
+        with pytest.raises(ValueError, match="test error"):
+            failing_test()
+
+    def test_logged_test_preserves_function_metadata(self):
+        @logged_test
+        def sample_function():
+            """Sample docstring"""
+            pass
+
+        assert sample_function.__name__ == "sample_function"
+        assert sample_function.__doc__ == "Sample docstring"
+
+    @pytest.mark.parametrize(
+        "args,kwargs,expected",
+        [
+            ((1, 2), {"c": 3}, 6),
+            ((5, 10), {}, 15),
+        ],
+    )
+    def test_logged_test_with_arguments(self, args, kwargs, expected):
+        @logged_test
+        def function_with_args(a, b, c=None):
+            return a + b + (c or 0)
+
+        result = function_with_args(*args, **kwargs)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "kwargs,expected",
+        [
+            ({"a": 1, "b": 2, "c": 3}, 6),
+            ({"x": 10, "y": 20}, 30),
+        ],
+    )
+    def test_logged_test_with_kwargs(self, kwargs, expected):
+        @logged_test
+        def function_with_kwargs(**kwargs):
+            return sum(kwargs.values())
+
+        result = function_with_kwargs(**kwargs)
+        assert result == expected
+
+    @patch("builtins.print")
+    def test_logged_test_prints_empty_line(self, mock_print):
+        @logged_test
+        def sample_test():
+            return "success"
+
+        sample_test()
+        mock_print.assert_called_once_with("")

tests/test_tree_node.py

@@ -0,0 +1,161 @@
+import pytest
+
+from leetcode_py.tree_node import TreeNode, build_anytree
+
+
+class TestTreeNode:
+    @pytest.mark.parametrize(
+        "val,expected_val",
+        [
+            (None, 0),  # default
+            (5, 5),  # with value
+        ],
+    )
+    def test_init(self, val, expected_val):
+        node = TreeNode() if val is None else TreeNode(val)
+        assert node.val == expected_val
+        assert node.left is None
+        assert node.right is None
+
+    def test_init_with_children(self):
+        left = TreeNode(1)
+        right = TreeNode(2)
+        node = TreeNode(0, left, right)
+        assert node.val == 0
+        assert node.left == left
+        assert node.right == right
+
+    def test_from_list_empty(self):
+        result = TreeNode.from_list([])
+        assert result is None
+
+    def test_from_list_none_root(self):
+        result = TreeNode.from_list([None])
+        assert result is None
+
+    def test_from_list_single(self):
+        result = TreeNode.from_list([1])
+        assert result is not None
+        assert result.val == 1
+        assert result.left is None
+        assert result.right is None
+
+    def test_from_list_complete_tree(self):
+        result = TreeNode.from_list([1, 2, 3, 4, 5, 6, 7])
+        assert result is not None
+        assert result.val == 1
+        assert result.left is not None
+        assert result.left.val == 2
+        assert result.right is not None
+        assert result.right.val == 3
+        assert result.left.left is not None
+        assert result.left.left.val == 4
+        assert result.left.right is not None
+        assert result.left.right.val == 5
+        assert result.right.left is not None
+        assert result.right.left.val == 6
+        assert result.right.right is not None
+        assert result.right.right.val == 7
+
+    def test_from_list_sparse_tree(self):
+        result = TreeNode.from_list([1, None, 2])
+        assert result is not None
+        assert result.val == 1
+        assert result.left is None
+        assert result.right is not None
+        assert result.right.val == 2
+        assert result.right.left is None
+        assert result.right.right is None
+
+    @pytest.mark.parametrize(
+        "input_list,expected_output",
+        [
+            ([1], [1]),
+            ([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5, 6, 7]),
+            ([1, None, 2], [1, None, 2]),
+        ],
+    )
+    def test_to_list(self, input_list, expected_output):
+        node = TreeNode.from_list(input_list)
+        assert node is not None
+        assert node.to_list() == expected_output
+
+    @pytest.mark.parametrize(
+        "input_list,expected_values",
+        [
+            ([1], ["1"]),
+            ([1, 2, 3], ["1", "2", "3"]),
+        ],
+    )
+    def test_str_representation(self, input_list, expected_values):
+        node = TreeNode.from_list(input_list)
+        assert node is not None
+        result = str(node)
+        for val in expected_values:
+            assert val in result
+
+    def test_repr_representation(self):
+        node = TreeNode.from_list([1, 2, 3])
+        assert node is not None
+        assert repr(node) == "TreeNode([1, 2, 3])"
+
+    def test_repr_html_generates_svg(self):
+        node = TreeNode.from_list([1, 2, 3])
+        assert node is not None
+        result = node._repr_html_()
+        assert isinstance(result, str)
+        assert "svg" in result.lower()
+
+    @pytest.mark.parametrize(
+        "list1,list2,should_equal",
+        [
+            ([1, 2, 3], [1, 2, 3], True),
+            ([1, 2, 3], [1, 3, 2], False),
+        ],
+    )
+    def test_equality(self, list1, list2, should_equal):
+        node1 = TreeNode.from_list(list1)
+        node2 = TreeNode.from_list(list2)
+        assert node1 is not None
+        assert node2 is not None
+        assert (node1 == node2) == should_equal
+
+    @pytest.mark.parametrize("other_value", [[1], "1"])
+    def test_equality_different_types(self, other_value):
+        node = TreeNode(1)
+        assert node != other_value
+
+    @pytest.mark.parametrize(
+        "test_list",
+        [
+            [1, 2, 3, 4, 5, None, 6],
+            [1],
+            [1, None, 2],
+        ],
+    )
+    def test_roundtrip_conversion(self, test_list):
+        node = TreeNode.from_list(test_list)
+        assert node is not None
+        result = node.to_list()
+        assert result == test_list
+
+    def test_build_anytree_none(self):
+        result = build_anytree(None)
+        assert result is None
+
+    def test_build_anytree_single_node(self):
+        node = TreeNode(1)
+        result = build_anytree(node)
+        assert result is not None
+        assert result.name == "1"
+        assert len(result.children) == 0
+
+    def test_str_with_none_tree(self):
+        # Create a scenario where build_anytree returns None
+        # This happens when we have a node but build_anytree fails
+        import unittest.mock
+
+        with unittest.mock.patch("leetcode_py.tree_node.build_anytree", return_value=None):
+            node = TreeNode(1)
+            result = str(node)
+            assert result == "None"