TestStrictFormatter Class — langchain Architecture

Source Code

libs/core/tests/unit_tests/utils/test_formatting.py lines 8–109

class TestStrictFormatter:
    """Tests for the `StrictFormatter` class."""

    def test_vformat_with_keyword_args(self) -> None:
        """Test that `vformat` works with keyword arguments."""
        fmt = StrictFormatter()
        result = fmt.vformat("Hello, {name}!", [], {"name": "World"})
        assert result == "Hello, World!"

    def test_vformat_with_multiple_keyword_args(self) -> None:
        """Test `vformat` with multiple keyword arguments."""
        fmt = StrictFormatter()
        result = fmt.vformat(
            "{greeting}, {name}! You have {count} messages.",
            [],
            {"greeting": "Hello", "name": "Alice", "count": 5},
        )
        assert result == "Hello, Alice! You have 5 messages."

    def test_vformat_with_empty_string(self) -> None:
        """Test `vformat` with empty format string."""
        fmt = StrictFormatter()
        result = fmt.vformat("", [], {})
        assert result == ""

    def test_vformat_with_no_placeholders(self) -> None:
        """Test `vformat` with no placeholders in format string."""
        fmt = StrictFormatter()
        result = fmt.vformat("Hello, World!", [], {})
        assert result == "Hello, World!"

    def test_vformat_raises_on_positional_args(self) -> None:
        """Test that `vformat` raises `ValueError` when positional args are provided."""
        fmt = StrictFormatter()
        with pytest.raises(
            ValueError,
            match=r"No arguments should be provided, "
            r"everything should be passed as keyword arguments\.",
        ):
            fmt.vformat("{}", ["arg"], {})

    def test_vformat_raises_on_multiple_positional_args(self) -> None:
        """Test that `vformat` raises `ValueError` with multiple positional args."""
        fmt = StrictFormatter()
        with pytest.raises(ValueError, match=r"No arguments should be provided"):
            fmt.vformat("{} {}", ["arg1", "arg2"], {})

    def test_vformat_with_special_characters(self) -> None:
        """Test `vformat` with special characters in values."""
        fmt = StrictFormatter()
        result = fmt.vformat("{text}", [], {"text": "Hello\nWorld\t!"})
        assert result == "Hello\nWorld\t!"

    def test_vformat_with_unicode(self) -> None:
        """Test `vformat` with unicode characters."""
        fmt = StrictFormatter()
        result = fmt.vformat(
            "{emoji} {text}", [], {"emoji": "🎉", "text": "こんにちは"}
        )
        assert result == "🎉 こんにちは"

    def test_vformat_with_format_spec(self) -> None:
        """Test `vformat` with format specifications."""
        fmt = StrictFormatter()
        result = fmt.vformat("{num:.2f}", [], {"num": 3.14159})
        assert result == "3.14"

    def test_vformat_with_nested_braces(self) -> None:
        """Test `vformat` with escaped braces."""
        fmt = StrictFormatter()
        result = fmt.vformat("{{literal}} {var}", [], {"var": "value"})
        assert result == "{literal} value"

    def test_validate_input_variables_success(self) -> None:
        """Test that `validate_input_variables` succeeds with valid input."""
        fmt = StrictFormatter()
        # Should not raise
        fmt.validate_input_variables("{name} {age}", ["name", "age"])

    def test_validate_input_variables_with_extra_variables(self) -> None:
        """Test `validate_input_variables` with extra variables (should succeed)."""