Add term validation tests with test data

Adds comprehensive term validation tests along with their test data files.

Test data files (5 files):
- terms.ftl: Basic term definitions and references
- terms_definitions.ftl: Terms for cross-file testing
- terms_messages.ftl: Messages referencing cross-file terms
- broken_terms.ftl: Invalid term references for error testing
- term_positional_args.ftl: Terms with positional arguments

Test updates:
- Updated parser error test for new error message format
- Added test_parser_error_has_structured_error_details

New term validation tests (13 tests):
- test_basic_term_reference
- test_term_attribute_as_selector
- test_multiple_term_references
- test_direct_term_access_fails
- test_unknown_term_validation_error
- test_unknown_term_attribute_validation_error
- test_terms_across_multiple_files
- test_strict_mode_rejects_unknown_terms
- test_term_positional_arguments_generate_validation_error
- test_strict_mode_rejects_term_positional_arguments
- test_term_positional_arguments_validation_has_correct_context

Tests validate term definitions, cross-file resolution, error detection,
and positional argument warnings.

Author: kevin-hua-kraken

tests/data/broken_terms.ftl

@@ -0,0 +1,13 @@
+# File with broken term references for testing validation
+
+-valid-term = This is a valid term
+    .case = nominative
+
+# Message references non-existent term
+broken-reference = This references { -nonexistent-term }
+
+# Message uses non-existent term attribute as selector
+broken-attribute = { -valid-term.nonexistent ->
+    [value] Something
+   *[other] Other
+}

tests/data/term_positional_args.ftl

@@ -0,0 +1,13 @@
+-brand-name = { $case ->
+   *[nominative] Firefox
+    [locative] Firefoxie
+}
+
+# This message uses a positional argument to a term (which is ignored per spec)
+bad-reference = Visit { -brand-name("positional") } for more info.
+
+# This message uses both positional and named arguments
+bad-reference-mixed = About { -brand-name("ignored", case: "locative") }.
+
+# This is the correct way - only named arguments
+good-reference = About { -brand-name(case: "locative") }.

tests/data/terms.ftl

@@ -0,0 +1,15 @@
+# Test file with Fluent terms
+-brand-name = Acme Corporation
+
+-product-name = Super Widget
+    .category = gadget
+
+# Messages that reference terms
+welcome = Welcome to { -brand-name }!
+product-info = Learn about { -product-name }
+
+# Message using term attribute as selector (this is valid per Fluent spec)
+product-category = { -product-name.category ->
+    [gadget] This is a gadget
+   *[other] This is something else
+}

tests/data/terms_definitions.ftl

@@ -0,0 +1,12 @@
+# Term definitions file
+# These terms can be referenced from other files
+
+-app-name = SuperApp
+
+-app-type =
+    { $type ->
+        [mobile] Mobile App
+       *[web] Web App
+    }
+
+-company-name = Acme Corporation

tests/data/terms_messages.ftl

@@ -0,0 +1,6 @@
+# Messages that reference terms from terms_definitions.ftl
+
+about-app = About { -app-name }
+app-title = { -app-name } - The Best App
+app-description = This is a { -app-type(type: "web") }
+company-info = Brought to you by { -company-name }

tests/test_python_interface.py

@@ -192,23 +192,58 @@ def test_raises_parser_error_on_file_that_contains_errors_in_strict_mode():
     message = "\n".join(lines)
     # End recombination
 
-    expected = f"""\
-  × Error when parsing {filename}
-   ╭─[1:16]
- 1 │ invalid-message
-   ·                ┬
-   ·                ╰── Expected a token starting with "="
- 2 │ 
- 3 │ valid-message = I'm valid.
-   ╰────
-"""
+    # Note: Line 2 has a trailing space after the pipe
+    expected = '  × Found 1 parse error(s) and 0 validation error(s)\n   ╭─[1:16]\n 1 │ invalid-message\n   ·                ┬\n   ·                ╰── Expected a token starting with "="\n 2 │ \n 3 │ valid-message = I\'m valid.\n   ╰────\n'
     assert message == expected
 
 
 def test_parser_error_str():
     assert str(fluent.ParserError) == "<class 'rustfluent.ParserError'>"
 
 
+def test_parser_error_has_structured_error_details():
+    """Test that ParserError exposes structured error information."""
+    filename = data_dir / "errors.ftl"
+
+    with pytest.raises(fluent.ParserError) as exc_info:
+        fluent.Bundle("fr", [filename], strict=True)
+
+    error = exc_info.value
+
+    # Verify the parse_errors attribute exists
+    assert hasattr(error, "parse_errors"), "ParserError should have 'parse_errors' attribute"
+    assert len(error.parse_errors) == 1, "Should have exactly one error"
+
+    # Verify the structure of the error detail
+    error_detail = error.parse_errors[0]
+    assert type(error_detail).__name__ == "ParseErrorDetail"
+
+    # Verify all expected attributes exist and have correct values
+    assert hasattr(error_detail, "message")
+    assert hasattr(error_detail, "line")
+    assert hasattr(error_detail, "column")
+    assert hasattr(error_detail, "byte_start")
+    assert hasattr(error_detail, "byte_end")
+    assert hasattr(error_detail, "filename")
+
+    # Verify the error is at the expected location
+    assert error_detail.line == 1
+    assert error_detail.column == 16
+    assert error_detail.byte_start == 15
+    assert error_detail.byte_end == 16
+
+    # Verify the message contains expected content
+    assert 'Expected a token starting with "="' in error_detail.message
+
+    # Verify filename is included
+    assert str(filename) in error_detail.filename
+
+    # Verify string representation works
+    error_str = str(error_detail)
+    assert "1:16" in error_str  # Line:column should be in string representation
+    assert "Expected a token" in error_str
+
+
 # Attribute access tests
 
 
@@ -288,3 +323,170 @@ def test_missing_attribute_raises_error():
 def test_attribute_and_message_access_parameterized(identifier, expected):
     bundle = fluent.Bundle("en", [data_dir / "attributes.ftl"])
     assert bundle.get_translation(identifier) == expected
+
+
+# ==============================================================================
+# Term Tests
+# ==============================================================================
+# Tests for Fluent terms - reusable vocabulary items that start with "-"
+# and can only be referenced within messages (not retrieved directly)
+
+
+def test_basic_term_reference():
+    """Test that messages can reference terms using { -term-name } syntax."""
+    bundle = fluent.Bundle("en", [data_dir / "terms.ftl"])
+    result = bundle.get_translation("welcome")
+    assert result == "Welcome to Acme Corporation!"
+
+
+def test_term_attribute_as_selector():
+    """Test that term attributes can be used as selectors in select expressions.
+
+    Note: Per Fluent spec, term attributes are private and can only be used
+    as selectors, not as direct placeables like { -term.attribute }.
+    """
+    bundle = fluent.Bundle("en", [data_dir / "terms.ftl"])
+    result = bundle.get_translation("product-category")
+    assert result == "This is a gadget"
+
+
+def test_multiple_term_references():
+    """Test that multiple messages can reference the same term."""
+    bundle = fluent.Bundle("en", [data_dir / "terms.ftl"])
+    assert bundle.get_translation("welcome") == "Welcome to Acme Corporation!"
+    assert bundle.get_translation("product-info") == "Learn about Super Widget"
+
+
+def test_direct_term_access_fails():
+    """Test that terms cannot be retrieved directly per Fluent spec."""
+    bundle = fluent.Bundle("en", [data_dir / "terms.ftl"])
+    with pytest.raises(ValueError, match="-brand-name not found"):
+        bundle.get_translation("-brand-name")
+
+
+def test_unknown_term_validation_error():
+    """Test that referencing a non-existent term generates a validation error."""
+    bundle = fluent.Bundle("en", [data_dir / "broken_terms.ftl"])
+
+    # Should have validation errors
+    validation_errors = bundle.get_validation_errors()
+    assert len(validation_errors) == 2  # One for unknown term, one for unknown attribute
+
+    # Find the unknown term error
+    unknown_term_errors = [e for e in validation_errors if e.error_type == "UnknownTerm"]
+    assert len(unknown_term_errors) == 1
+
+    error = unknown_term_errors[0]
+    assert error.error_type == "UnknownTerm"
+    assert "-nonexistent-term" in error.message or "nonexistent-term" in error.message
+    assert error.message_id == "broken-reference"
+
+
+def test_unknown_term_attribute_validation_error():
+    """Test that referencing a non-existent term attribute generates a validation error."""
+    bundle = fluent.Bundle("en", [data_dir / "broken_terms.ftl"])
+
+    # Should have validation errors
+    validation_errors = bundle.get_validation_errors()
+    assert len(validation_errors) == 2  # One for unknown term, one for unknown attribute
+
+    # Find the unknown attribute error
+    unknown_attr_errors = [e for e in validation_errors if e.error_type == "UnknownAttribute"]
+    assert len(unknown_attr_errors) == 1
+
+    error = unknown_attr_errors[0]
+    assert error.error_type == "UnknownAttribute"
+    assert "nonexistent" in error.message
+    assert error.message_id == "broken-attribute"
+
+
+def test_terms_across_multiple_files():
+    """Test that terms defined in one file can be referenced in messages from another file."""
+    # Load terms file first, then messages file
+    bundle = fluent.Bundle(
+        "en", [data_dir / "terms_definitions.ftl", data_dir / "terms_messages.ftl"]
+    )
+
+    # Should have no validation errors
+    assert len(bundle.get_validation_errors()) == 0
+
+    # Verify messages correctly reference terms from the other file
+    assert bundle.get_translation("about-app") == "About SuperApp"
+    assert bundle.get_translation("app-title") == "SuperApp - The Best App"
+    assert bundle.get_translation("app-description") == "This is a Web App"
+    assert bundle.get_translation("company-info") == "Brought to you by Acme Corporation"
+
+
+def test_strict_mode_rejects_unknown_terms():
+    """Test that strict mode raises an error when unknown terms are referenced.
+
+    Note: When there are only validation errors (no parse errors), a ValueError
+    is raised. When there are parse errors, a ParserError is raised.
+    """
+    with pytest.raises(ValueError) as exc_info:
+        fluent.Bundle("en", [data_dir / "broken_terms.ftl"], strict=True)
+
+    error = exc_info.value
+
+    # Should have validation errors
+    assert hasattr(error, "validation_errors")
+    assert len(error.validation_errors) == 2
+
+    # Check that the errors mention the unknown term and attribute
+    error_messages = [e.message for e in error.validation_errors]
+    assert any("nonexistent-term" in msg for msg in error_messages)
+    assert any("nonexistent" in msg and "attribute" in msg.lower() for msg in error_messages)
+
+
+def test_term_positional_arguments_generate_validation_error():
+    """Test that positional arguments to terms generate a validation error.
+
+    Per Fluent spec, positional arguments to terms are syntactically valid but
+    semantically ignored at runtime. We warn about them to prevent confusion.
+    """
+    bundle = fluent.Bundle("en", [data_dir / "term_positional_args.ftl"])
+
+    # Should have validation errors for the two messages with positional args
+    validation_errors = bundle.get_validation_errors()
+    assert len(validation_errors) == 2
+
+    # Both errors should be about ignored positional arguments
+    for error in validation_errors:
+        assert error.error_type == "IgnoredPositionalArgument"
+        assert "positional" in error.message.lower() or "ignored" in error.message.lower()
+        assert "-brand-name" in error.message
+        assert error.message_id in ["bad-reference", "bad-reference-mixed"]
+
+    # The good reference should still work correctly
+    assert bundle.get_translation("good-reference") == "About Firefoxie."
+
+
+def test_strict_mode_rejects_term_positional_arguments():
+    """Test that strict mode raises an error when terms are given positional arguments."""
+    with pytest.raises(ValueError) as exc_info:
+        fluent.Bundle("en", [data_dir / "term_positional_args.ftl"], strict=True)
+
+    error = exc_info.value
+
+    # Should have validation errors
+    assert hasattr(error, "validation_errors")
+    assert len(error.validation_errors) == 2
+
+    # Check that the errors mention positional arguments
+    error_messages = [e.message for e in error.validation_errors]
+    assert all("positional" in msg.lower() or "ignored" in msg.lower() for msg in error_messages)
+
+
+def test_term_positional_arguments_validation_has_correct_context():
+    """Test that positional argument validation errors have correct context."""
+    bundle = fluent.Bundle("en", [data_dir / "term_positional_args.ftl"])
+
+    validation_errors = bundle.get_validation_errors()
+
+    # Find the error for bad-reference
+    bad_ref_error = next(e for e in validation_errors if e.message_id == "bad-reference")
+
+    assert bad_ref_error.error_type == "IgnoredPositionalArgument"
+    assert bad_ref_error.message_id == "bad-reference"
+    assert bad_ref_error.reference == "-brand-name"
+    assert "named arguments" in bad_ref_error.message