Add tests for string helpers too, update timestamp strings tests

Fix string helpers calls for some edge cases

tests/unit/string_handling/test_string_helpers.py

@@ -0,0 +1,237 @@
+"""
+PyTest: string_handling/string_helpers
+"""
+
+import pytest
+from textwrap import shorten
+from corelibs.string_handling.string_helpers import shorten_string, left_fill, format_number
+
+
+class TestShortenString:
+    """Tests for shorten_string function"""
+
+    def test_string_shorter_than_length(self):
+        """Test that strings shorter than length are returned unchanged"""
+        result = shorten_string("hello", 10)
+        assert result == "hello"
+
+    def test_string_equal_to_length(self):
+        """Test that strings equal to length are returned unchanged"""
+        result = shorten_string("hello", 5)
+        assert result == "hello"
+
+    def test_hard_shorten_true(self):
+        """Test hard shortening with default placeholder"""
+        result = shorten_string("hello world", 8, hard_shorten=True)
+        assert result == "hell [~]"
+
+    def test_hard_shorten_custom_placeholder(self):
+        """Test hard shortening with custom placeholder"""
+        result = shorten_string("hello world", 8, hard_shorten=True, placeholder="...")
+        assert result == "hello..."
+
+    def test_no_spaces_auto_hard_shorten(self):
+        """Test that strings without spaces automatically use hard shorten"""
+        result = shorten_string("helloworld", 8)
+        assert result == "hell [~]"
+
+    def test_soft_shorten_with_spaces(self):
+        """Test soft shortening using textwrap.shorten"""
+        result = shorten_string("hello world test", 12)
+        # Should use textwrap.shorten behavior
+        expected = shorten("hello world test", width=12, placeholder=" [~]")
+        assert result == expected
+
+    def test_placeholder_too_large_hard_shorten(self):
+        """Test error when placeholder is larger than allowed length"""
+        with pytest.raises(ValueError, match="Cannot shorten string: placeholder .* is too large for max width"):
+            shorten_string("hello", 3, hard_shorten=True, placeholder=" [~]")
+
+    def test_placeholder_too_large_no_spaces(self):
+        """Test error when placeholder is larger than allowed length for string without spaces"""
+        with pytest.raises(ValueError, match="Cannot shorten string: placeholder .* is too large for max width"):
+            shorten_string("hello", 3, placeholder=" [~]")
+
+    def test_textwrap_shorten_error(self):
+        """Test handling of textwrap.shorten ValueError"""
+        # This might be tricky to trigger, but we can mock it
+        with pytest.raises(ValueError, match="Cannot shorten string:"):
+            # Very short length that might cause textwrap.shorten to fail
+            shorten_string("hello world", 1, hard_shorten=False)
+
+    def test_type_conversion(self):
+        """Test that inputs are converted to proper types"""
+        result = shorten_string(12345, 8, hard_shorten=True)
+        assert result == "12345"
+
+    def test_empty_string(self):
+        """Test with empty string"""
+        result = shorten_string("", 5)
+        assert result == ""
+
+    def test_zero_length(self):
+        """Test with zero length"""
+        with pytest.raises(ValueError):
+            shorten_string("hello", 0, hard_shorten=True)
+
+
+class TestLeftFill:
+    """Tests for left_fill function"""
+
+    def test_basic_left_fill(self):
+        """Test basic left filling with spaces"""
+        result = left_fill("hello", 10)
+        assert result == "     hello"
+        assert len(result) == 10
+
+    def test_custom_fill_character(self):
+        """Test left filling with custom character"""
+        result = left_fill("hello", 10, "0")
+        assert result == "00000hello"
+
+    def test_string_longer_than_width(self):
+        """Test when string is longer than width"""
+        result = left_fill("hello world", 5)
+        assert result == "hello world"  # Should return original string
+
+    def test_string_equal_to_width(self):
+        """Test when string equals width"""
+        result = left_fill("hello", 5)
+        assert result == "hello"
+
+    def test_negative_width(self):
+        """Test with negative width"""
+        result = left_fill("hello", -5)
+        assert result == "hello"  # Should use string length
+
+    def test_zero_width(self):
+        """Test with zero width"""
+        result = left_fill("hello", 0)
+        assert result == "hello"  # Should return original string
+
+    def test_invalid_fill_character(self):
+        """Test with invalid fill character (not single char)"""
+        result = left_fill("hello", 10, "abc")
+        assert result == "     hello"  # Should default to space
+
+    def test_empty_fill_character(self):
+        """Test with empty fill character"""
+        result = left_fill("hello", 10, "")
+        assert result == "     hello"  # Should default to space
+
+    def test_empty_string(self):
+        """Test with empty string"""
+        result = left_fill("", 5)
+        assert result == "     "
+
+
+class TestFormatNumber:
+    """Tests for format_number function"""
+
+    def test_integer_default_precision(self):
+        """Test formatting integer with default precision"""
+        result = format_number(1234)
+        assert result == "1,234"
+
+    def test_float_default_precision(self):
+        """Test formatting float with default precision"""
+        result = format_number(1234.56)
+        assert result == "1,235"  # Should round to nearest integer
+
+    def test_with_precision(self):
+        """Test formatting with specified precision"""
+        result = format_number(1234.5678, 2)
+        assert result == "1,234.57"
+
+    def test_large_number(self):
+        """Test formatting large number"""
+        result = format_number(1234567.89, 2)
+        assert result == "1,234,567.89"
+
+    def test_zero(self):
+        """Test formatting zero"""
+        result = format_number(0)
+        assert result == "0"
+
+    def test_negative_number(self):
+        """Test formatting negative number"""
+        result = format_number(-1234.56, 2)
+        assert result == "-1,234.56"
+
+    def test_negative_precision(self):
+        """Test with negative precision (should default to 0)"""
+        result = format_number(1234.56, -1)
+        assert result == "1,235"
+
+    def test_excessive_precision(self):
+        """Test with precision > 100 (should default to 0)"""
+        result = format_number(1234.56, 101)
+        assert result == "1,235"
+
+    def test_precision_boundary_values(self):
+        """Test precision boundary values"""
+        # Test precision = 0 (should work)
+        result = format_number(1234.56, 0)
+        assert result == "1,235"
+
+        # Test precision = 100 (should work)
+        result = format_number(1234.56, 100)
+        assert "1,234.56" in result  # Will have many trailing zeros
+
+    def test_small_decimal(self):
+        """Test formatting small decimal number"""
+        result = format_number(0.123456, 4)
+        assert result == "0.1235"
+
+    def test_very_small_number(self):
+        """Test formatting very small number"""
+        result = format_number(0.001, 3)
+        assert result == "0.001"
+
+
+# Additional integration tests
+class TestIntegration:
+    """Integration tests combining functions"""
+
+    def test_format_and_fill(self):
+        """Test formatting a number then left filling"""
+        formatted = format_number(1234.56, 2)
+        result = left_fill(formatted, 15)
+        assert result.endswith("1,234.56")
+        assert len(result) == 15
+
+    def test_format_and_shorten(self):
+        """Test formatting a large number then shortening"""
+        formatted = format_number(123456789.123, 3)
+        result = shorten_string(formatted, 10)
+        assert len(result) <= 10
+
+
+# Fixtures for parameterized tests
+@pytest.mark.parametrize("input_str,length,expected", [
+    ("hello", 10, "hello"),
+    ("hello world", 5, "h [~]"),
+    ("test", 4, "test"),
+    ("", 5, ""),
+])
+def test_shorten_string_parametrized(input_str: str, length: int, expected: str):
+    """Parametrized test for shorten_string"""
+    result = shorten_string(input_str, length, hard_shorten=True)
+    if expected.endswith(" [~]"):
+        assert result.endswith(" [~]")
+        assert len(result) == length
+    else:
+        assert result == expected
+
+
+@pytest.mark.parametrize("number,precision,expected", [
+    (1000, 0, "1,000"),
+    (1234.56, 2, "1,234.56"),
+    (0, 1, "0.0"),
+    (-500, 0, "-500"),
+])
+def test_format_number_parametrized(number: float | int, precision: int, expected: str):
+    """Parametrized test for format_number"""
+    assert format_number(number, precision) == expected
+
+# __END__

tests/unit/string_handling/test_timestamp_strings.py

@@ -153,3 +153,5 @@ class TestTimestampStrings:
 
             assert ts.today == '2024-01-01'
             assert ts.timestamp == '2024-01-01 00:00:00'
+
+# __END__