add missing tests and organize existing tests better

Author: xulbux

tests/test_code.py

@@ -1,5 +1,8 @@
 from xulbux.code import Code
 
+#
+################################################## Code TESTS ##################################################
+
 
 def test_add_indent():
     sample = "def hello():\n    return 'Hello, World!'"

tests/test_color.py

@@ -1,5 +1,8 @@
 from xulbux.color import Color, rgba, hsla, hexa
 
+#
+################################################## Color TESTS ##################################################
+
 
 def test_rgba_to_hex_int_and_back():
     blue = Color.rgba_to_hex_int(0, 0, 255)

tests/test_color_types.py

@@ -22,6 +22,9 @@ def assert_hexa_equal(actual: hexa, expected: str):
     assert str(actual) == expected
 
 
+################################################## rgba TESTS ##################################################
+
+
 def test_rgba_return_values():
     assert_rgba_equal(rgba(255, 0, 0, 0.5), (255, 0, 0, 0.5))
     assert_hsla_equal(rgba(255, 0, 0, 0.5).to_hsla(), (0, 100, 50, 0.5))
@@ -48,6 +51,41 @@ def test_rgba_return_values():
     assert_rgba_equal(rgba(255, 0, 0, 0.5).complementary(), (0, 255, 255, 0.5))
 
 
+def test_rgba_construction():
+    assert rgba(100, 150, 200).values() == (100, 150, 200, None)
+    assert rgba(100, 150, 200, 0.5).values() == (100, 150, 200, 0.5)
+    assert rgba(0, 0, 0).values() == (0, 0, 0, None)
+    assert rgba(255, 255, 255).values() == (255, 255, 255, None)
+    try:
+        rgba(300, 150, 200)
+        assert False, "Should raise ValueError for invalid RGB values"
+    except ValueError:
+        pass
+    try:
+        rgba(100, 150, 200, 2.0)
+        assert False, "Should raise ValueError for invalid alpha value"
+    except ValueError:
+        pass
+
+
+def test_rgba_dunder_methods():
+    assert len(rgba(100, 150, 200)) == 3
+    assert len(rgba(100, 150, 200, 0.5)) == 4
+    color = rgba(100, 150, 200, 0.5)
+    assert color[0] == 100
+    assert color[1] == 150
+    assert color[2] == 200
+    assert color[3] == 0.5
+    assert rgba(100, 150, 200) == rgba(100, 150, 200)
+    assert rgba(100, 150, 200) != rgba(200, 100, 150)
+    assert str(rgba(100, 150, 200)) == "(100, 150, 200)"
+    assert str(rgba(100, 150, 200, 0.5)) == "(100, 150, 200, 0.5)"
+    assert repr(rgba(100, 150, 200)).startswith("rgba(")
+
+
+################################################## hsla TESTS ##################################################
+
+
 def test_hsla_return_values():
     assert_hsla_equal(hsla(0, 100, 50, 0.5), (0, 100, 50, 0.5))
     assert_rgba_equal(hsla(0, 100, 50, 0.5).to_rgba(), (255, 0, 0, 0.5))
@@ -74,6 +112,41 @@ def test_hsla_return_values():
     assert_hsla_equal(hsla(0, 100, 50, 0.5).complementary(), (180, 100, 50, 0.5))
 
 
+def test_hsla_construction():
+    assert hsla(210, 50, 60).values() == (210, 50, 60, None)
+    assert hsla(210, 50, 60, 0.5).values() == (210, 50, 60, 0.5)
+    assert hsla(0, 0, 0).values() == (0, 0, 0, None)
+    assert hsla(360, 100, 100).values() == (360, 100, 100, None)
+    try:
+        hsla(361, 50, 60)
+        assert False, "Should raise ValueError for invalid hue value"
+    except ValueError:
+        pass
+    try:
+        hsla(210, 101, 60)
+        assert False, "Should raise ValueError for invalid saturation value"
+    except ValueError:
+        pass
+
+
+def test_hsla_dunder_methods():
+    assert len(hsla(210, 50, 60)) == 3
+    assert len(hsla(210, 50, 60, 0.5)) == 4
+    color = hsla(210, 50, 60, 0.5)
+    assert color[0] == 210
+    assert color[1] == 50
+    assert color[2] == 60
+    assert color[3] == 0.5
+    assert hsla(210, 50, 60) == hsla(210, 50, 60)
+    assert hsla(210, 50, 60) != hsla(210, 60, 50)
+    assert str(hsla(210, 50, 60)) == "(210°, 50%, 60%)"
+    assert str(hsla(210, 50, 60, 0.5)) == "(210°, 50%, 60%, 0.5)"
+    assert repr(hsla(210, 50, 60)).startswith("hsla(")
+
+
+################################################## hexa TESTS ##################################################
+
+
 def test_hexa_return_values():
     assert_hexa_equal(hexa("#F008"), "#FF000088")
     assert_rgba_equal(hexa("#FF00007F").to_rgba(), (255, 0, 0, 0.5))
@@ -100,40 +173,6 @@ def test_hexa_return_values():
     assert_hexa_equal(hexa("#FF00007F").complementary(), "#00FFFF7F")
 
 
-def test_rgba_construction():
-    assert rgba(100, 150, 200).values() == (100, 150, 200, None)
-    assert rgba(100, 150, 200, 0.5).values() == (100, 150, 200, 0.5)
-    assert rgba(0, 0, 0).values() == (0, 0, 0, None)
-    assert rgba(255, 255, 255).values() == (255, 255, 255, None)
-    try:
-        rgba(300, 150, 200)
-        assert False, "Should raise ValueError for invalid RGB values"
-    except ValueError:
-        pass
-    try:
-        rgba(100, 150, 200, 2.0)
-        assert False, "Should raise ValueError for invalid alpha value"
-    except ValueError:
-        pass
-
-
-def test_hsla_construction():
-    assert hsla(210, 50, 60).values() == (210, 50, 60, None)
-    assert hsla(210, 50, 60, 0.5).values() == (210, 50, 60, 0.5)
-    assert hsla(0, 0, 0).values() == (0, 0, 0, None)
-    assert hsla(360, 100, 100).values() == (360, 100, 100, None)
-    try:
-        hsla(361, 50, 60)
-        assert False, "Should raise ValueError for invalid hue value"
-    except ValueError:
-        pass
-    try:
-        hsla(210, 101, 60)
-        assert False, "Should raise ValueError for invalid saturation value"
-    except ValueError:
-        pass
-
-
 def test_hexa_construction():
     assert hexa("#F00").values() == (255, 0, 0, None)
     assert hexa("#F008").values(True) == (255, 0, 0, 0.53)
@@ -153,36 +192,6 @@ def test_hexa_construction():
         pass
 
 
-def test_rgba_dunder_methods():
-    assert len(rgba(100, 150, 200)) == 3
-    assert len(rgba(100, 150, 200, 0.5)) == 4
-    color = rgba(100, 150, 200, 0.5)
-    assert color[0] == 100
-    assert color[1] == 150
-    assert color[2] == 200
-    assert color[3] == 0.5
-    assert rgba(100, 150, 200) == rgba(100, 150, 200)
-    assert rgba(100, 150, 200) != rgba(200, 100, 150)
-    assert str(rgba(100, 150, 200)) == "(100, 150, 200)"
-    assert str(rgba(100, 150, 200, 0.5)) == "(100, 150, 200, 0.5)"
-    assert repr(rgba(100, 150, 200)).startswith("rgba(")
-
-
-def test_hsla_dunder_methods():
-    assert len(hsla(210, 50, 60)) == 3
-    assert len(hsla(210, 50, 60, 0.5)) == 4
-    color = hsla(210, 50, 60, 0.5)
-    assert color[0] == 210
-    assert color[1] == 50
-    assert color[2] == 60
-    assert color[3] == 0.5
-    assert hsla(210, 50, 60) == hsla(210, 50, 60)
-    assert hsla(210, 50, 60) != hsla(210, 60, 50)
-    assert str(hsla(210, 50, 60)) == "(210°, 50%, 60%)"
-    assert str(hsla(210, 50, 60, 0.5)) == "(210°, 50%, 60%, 0.5)"
-    assert repr(hsla(210, 50, 60)).startswith("hsla(")
-
-
 def test_hexa_dunder_methods():
     assert len(hexa("#F00")) == 3
     assert len(hexa("#F008")) == 4

tests/test_console.py

@@ -1,4 +1,6 @@
-from xulbux.console import ProgressBar, Console, ArgResult, Args
+from xulbux.console import Spinner, ProgressBar
+from xulbux.console import ArgResult, Args
+from xulbux.console import Console
 from xulbux import console
 
 from unittest.mock import MagicMock, patch, call
@@ -37,7 +39,7 @@ def mock_prompt_toolkit(monkeypatch):
     return mock
 
 
-################################################## CONSOLE TESTS ##################################################
+################################################## Console TESTS ##################################################
 
 
 def test_console_user():
@@ -928,7 +930,7 @@ def test_input_custom_style_object(mock_prompt_session, mock_formatcodes_print):
     assert hasattr(style, "style_rules") or hasattr(style, "_style")
 
 
-################################################## PROGRESSBAR TESTS ##################################################
+################################################## ProgressBar TESTS ##################################################
 
 
 def test_progressbar_init():
@@ -1117,3 +1119,126 @@ def test_progressbar_redraw_progress_bar():
     pb._current_progress_str = "\x1b[2K\rLoading |████████████| 50%"
     pb._redraw_display()
     mock_stdout.flush.assert_called_once()
+
+
+################################################## Spinner TESTS ##################################################
+
+
+def test_spinner_init_defaults():
+    spinner = Spinner()
+    assert spinner.label is None
+    assert spinner.interval == 0.2
+    assert spinner.active is False
+    assert spinner.sep == " "
+    assert len(spinner.frames) > 0
+
+
+def test_spinner_init_custom():
+    spinner = Spinner(label="Loading", interval=0.5, sep="-")
+    assert spinner.label == "Loading"
+    assert spinner.interval == 0.5
+    assert spinner.sep == "-"
+
+
+def test_spinner_set_format_valid():
+    spinner = Spinner()
+    spinner.set_format(["{l}", "{a}"])
+    assert spinner.spinner_format == ["{l}", "{a}"]
+
+
+def test_spinner_set_format_invalid():
+    spinner = Spinner()
+    with pytest.raises(ValueError):
+        spinner.set_format(["{l}"])  # MISSING {a}
+
+
+def test_spinner_set_frames_valid():
+    spinner = Spinner()
+    spinner.set_frames(("a", "b"))
+    assert spinner.frames == ("a", "b")
+
+
+def test_spinner_set_frames_invalid():
+    spinner = Spinner()
+    with pytest.raises(ValueError):
+        spinner.set_frames(("a", ))  # LESS THAN 2 FRAMES
+
+
+def test_spinner_set_interval_valid():
+    spinner = Spinner()
+    spinner.set_interval(1.0)
+    assert spinner.interval == 1.0
+
+
+def test_spinner_set_interval_invalid():
+    spinner = Spinner()
+    with pytest.raises(ValueError):
+        spinner.set_interval(0)
+    with pytest.raises(ValueError):
+        spinner.set_interval(-1)
+
+
+@patch("xulbux.console._threading.Thread")
+@patch("xulbux.console._threading.Event")
+@patch("sys.stdout", new_callable=MagicMock)
+def test_spinner_start(mock_stdout, mock_event, mock_thread):
+    spinner = Spinner()
+    spinner.start("Test")
+
+    assert spinner.active is True
+    assert spinner.label == "Test"
+    mock_event.assert_called_once()
+    mock_thread.assert_called_once()
+
+    # TEST CALLING START AGAIN DOESN'T DO ANYTHING
+    spinner.start("Test2")
+    assert mock_event.call_count == 1
+
+
+@patch("xulbux.console._threading.Thread")
+@patch("xulbux.console._threading.Event")
+def test_spinner_stop(mock_event, mock_thread):
+    spinner = Spinner()
+    # MANUALLY SET ACTIVE TO SIMULATE RUNNING
+    spinner.active = True
+    mock_stop_event = MagicMock()
+    spinner._stop_event = mock_stop_event
+    mock_animation_thread = MagicMock()
+    spinner._animation_thread = mock_animation_thread
+
+    spinner.stop()
+
+    assert spinner.active is False
+    mock_stop_event.set.assert_called_once()
+    mock_animation_thread.join.assert_called_once()
+
+
+def test_spinner_update_label():
+    spinner = Spinner()
+    spinner.update_label("New Label")
+    assert spinner.label == "New Label"
+
+
+def test_spinner_context_manager():
+    spinner = Spinner()
+    with patch.object(spinner, "start") as mock_start, patch.object(spinner, "stop") as mock_stop:
+
+        with spinner.context("Test") as update:
+            mock_start.assert_called_with("Test")
+            update("New Label")
+            assert spinner.label == "New Label"
+
+        mock_stop.assert_called_once()
+
+
+def test_spinner_context_manager_exception():
+    spinner = Spinner()
+    with patch.object(spinner, "start"), patch.object(spinner, "stop") as mock_stop, \
+        patch.object(spinner, "_emergency_cleanup") as mock_cleanup:
+
+        with pytest.raises(ValueError):
+            with spinner.context("Test"):
+                raise ValueError("Oops")
+
+        mock_cleanup.assert_called_once()
+        mock_stop.assert_called_once()

tests/test_data.py

@@ -29,6 +29,9 @@
 d1_path_id = {"healthy": {"fruit": ["apples", "bananas", "oranges"], "vegetables": ["carrots", "broccoli", "celery"]}}
 d2_path_id = {"school": {"material": ["pencil", "paper", "rubber"], "subjects": ["math", "science", "history"]}}
 
+#
+################################################## Data TESTS ##################################################
+
 
 def test_serialize_bytes():
     utf8_bytes = b"Hello"

tests/test_env_path.py

@@ -1,5 +1,8 @@
 from xulbux.env_path import EnvPath
 
+#
+################################################## EnvPath TESTS ##################################################
+
 
 def test_get_paths():
     paths = EnvPath.paths()

tests/test_file.py

@@ -4,6 +4,9 @@
 import pytest
 import os
 
+#
+################################################## File TESTS ##################################################
+
 
 @pytest.mark.parametrize(
     "input_file, new_extension, camel_case, full_extension, expected_output", [

tests/test_format_codes.py

@@ -20,6 +20,9 @@
 reset_invert = f"{ANSI.CHAR}{ANSI.START}{ANSI.CODES_MAP[('_inverse', '_invert', '_in')]}{ANSI.END}"
 reset_underline = f"{ANSI.CHAR}{ANSI.START}{ANSI.CODES_MAP[('_underline', '_u')]}{ANSI.END}"
 
+#
+################################################## FormatCodes TESTS ##################################################
+
 
 def test_to_ansi():
     assert (

tests/test_json.py

@@ -80,6 +80,9 @@ def create_test_json_string(tmp_path, filename, content):
     "user": {"name": "Test User", "admin": True},
 }
 
+#
+################################################## Json TESTS ##################################################
+
 
 def test_read_simple(tmp_path):
     file_path = create_test_json(tmp_path, "simple.json", SIMPLE_DATA)