@ngocsangairvds/vsaf 3.2.14 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/tests/unit/state/test_hybrid_search.py

@@ -1,398 +0,0 @@
-"""Unit tests for RRF hybrid retrieval SQL functions.
-
-Phase 47 Track K (TSK-473): RRF Hybrid Retrieval SQL Functions
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-from vds_audit_orchestrator.state.store import (
-    HybridSearchResult,
-    PostgresStateStore,
-    _as_pgvector_literal,
-)
-
-# P4 / TSK-4.1.8: BOOTSTRAP_FUNCTIONS_SQL was retired when init_schema() moved
-# to Alembic.  Schema CONTENT tests now read the squash migration source.
-_SQUASH_PATH = Path(__file__).resolve().parents[3] / "alembic" / "versions" / "0001_initial_audit_state_schema.py"
-_SQUASH_SOURCE = _SQUASH_PATH.read_text(encoding="utf-8")
-
-
-class TestRrfScoreFunction:
-    """Tests for the rrf_score SQL function behavior via Python validation."""
-
-    def test_rrf_score_rank_one_returns_expected_value(self) -> None:
-        """RRF score for rank=1 with k=60 should be 1/(60+1) = 0.0164..."""
-        # The SQL function: 1.0 / (60 + 1) = 0.0163934426...
-        rank = 1
-        rrf_k = 60
-        expected = 1.0 / (rrf_k + rank)
-        assert abs(expected - 0.0163934426) < 1e-9
-
-    def test_rrf_score_higher_rank_lower_score(self) -> None:
-        """Higher ranks should produce lower RRF scores."""
-        rrf_k = 60
-        score_1 = 1.0 / (rrf_k + 1)
-        score_2 = 1.0 / (rrf_k + 2)
-        score_10 = 1.0 / (rrf_k + 10)
-        assert score_1 > score_2 > score_10
-
-    def test_rrf_score_null_rank_returns_zero(self) -> None:
-        """Per SQL function, NULL rank should return 0."""
-        # The SQL: WHEN rank IS NULL OR rank < 1 THEN 0
-        # This is validated in the SQL, but we document the expected behavior
-        pass  # SQL-level validation
-
-    def test_rrf_score_negative_rank_returns_zero(self) -> None:
-        """Per SQL function, rank < 1 should return 0."""
-        # The SQL: WHEN rank IS NULL OR rank < 1 THEN 0
-        pass  # SQL-level validation
-
-
-class TestAsPgvectorLiteral:
-    """Tests for the _as_pgvector_literal helper function."""
-
-    def test_simple_embedding(self) -> None:
-        """Basic embedding vector should format correctly."""
-        embedding = [0.1, 0.2, 0.3]
-        result = _as_pgvector_literal(embedding)
-        assert result == "[0.1,0.2,0.3]"
-
-    def test_negative_values(self) -> None:
-        """Negative values should be preserved."""
-        embedding = [-0.5, 0.0, 0.5]
-        result = _as_pgvector_literal(embedding)
-        assert result == "[-0.5,0,0.5]"
-
-    def test_precision_truncation(self) -> None:
-        """Values with many decimal places should use .12g format."""
-        embedding = [0.123456789012345, 0.987654321098765]
-        result = _as_pgvector_literal(embedding)
-        # .12g format: 0.123456789012345 -> "0.123456789012" (12 significant digits)
-        # 0.987654321098765 -> "0.987654321099" (12 significant digits, rounded)
-        assert result.startswith("[0.123456789012")
-        assert "0.98765432109" in result  # Check prefix that's stable across rounding
-
-    def test_scientific_notation(self) -> None:
-        """Very small values may use scientific notation."""
-        embedding = [1e-10, 1e10]
-        result = _as_pgvector_literal(embedding)
-        assert "1e-10" in result or "1.00000000000e-10" in result
-        assert "1e+10" in result or "10000000000" in result
-
-
-class TestHybridSearchMethod:
-    """Tests for the PostgresStateStore.hybrid_search Python wrapper."""
-
-    def test_hybrid_search_calls_sql_function_with_correct_parameters(self) -> None:
-        """hybrid_search should call the SQL function with all parameters."""
-        with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-            conn = MagicMock()
-            cur = MagicMock()
-            cur.fetchall.return_value = []
-            conn.cursor.return_value.__enter__.return_value = cur
-            mock_connect.return_value = conn
-
-            store = PostgresStateStore("postgresql://test")
-            query_embedding = [0.1] * 384  # Mock 384-dim embedding
-
-            results = store.hybrid_search(
-                project_key="test-project",
-                repo_key="test-repo",
-                query_text="authentication flow",
-                query_embedding=query_embedding,
-                top_k=5,
-                lexical_weight=0.3,
-                vector_weight=0.7,
-                snapshot_id=42,
-            )
-
-            assert results == []
-            sql, params = cur.execute.call_args[0]
-
-            # Verify SQL calls the hybrid_search function
-            assert "audit_state.hybrid_search" in sql
-            assert "p_project_key := %s" in sql
-            assert "p_repo_key := %s" in sql
-            assert "p_query_text := %s" in sql
-            assert "p_query_embedding := %s::vector" in sql
-            assert "p_top_k := %s" in sql
-            assert "p_lexical_weight := %s" in sql
-            assert "p_vector_weight := %s" in sql
-            assert "p_snapshot_id := %s" in sql
-
-            # Verify parameters
-            assert params[0] == "test-project"
-            assert params[1] == "test-repo"
-            assert params[2] == "authentication flow"
-            assert params[4] == 5
-            assert params[5] == 0.3
-            assert params[6] == 0.7
-            assert params[7] == 42
-
-    def test_hybrid_search_returns_typed_results(self) -> None:
-        """hybrid_search should return properly typed HybridSearchResult items."""
-        with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-            conn = MagicMock()
-            cur = MagicMock()
-            mock_results = [
-                {
-                    "chunk_pk": 1,
-                    "document_id": "doc-1",
-                    "chunk_id": "chunk-1",
-                    "content_text": "Sample content",
-                    "source_uri": "https://example.com/doc",
-                    "page_id": "12345",
-                    "content_hash": "abc123",
-                    "metadata": {"source": "confluence"},
-                    "lexical_rank": 1,
-                    "vector_rank": 2,
-                    "rrf_score": 0.025,
-                },
-                {
-                    "chunk_pk": 2,
-                    "document_id": "doc-2",
-                    "chunk_id": "chunk-2",
-                    "content_text": "Another content",
-                    "source_uri": None,
-                    "page_id": None,
-                    "content_hash": "def456",
-                    "metadata": {},
-                    "lexical_rank": None,
-                    "vector_rank": 1,
-                    "rrf_score": 0.020,
-                },
-            ]
-            cur.fetchall.return_value = mock_results
-            conn.cursor.return_value.__enter__.return_value = cur
-            mock_connect.return_value = conn
-
-            store = PostgresStateStore("postgresql://test")
-            results = store.hybrid_search(
-                project_key="test-project",
-                query_text="test query",
-                query_embedding=[0.1] * 384,
-            )
-
-            assert len(results) == 2
-            assert results[0]["chunk_pk"] == 1
-            assert results[0]["document_id"] == "doc-1"
-            assert results[0]["lexical_rank"] == 1
-            assert results[0]["vector_rank"] == 2
-            assert results[1]["lexical_rank"] is None
-            assert results[1]["vector_rank"] == 1
-
-    def test_hybrid_search_with_optional_repo_key_none(self) -> None:
-        """hybrid_search should handle repo_key=None correctly."""
-        with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-            conn = MagicMock()
-            cur = MagicMock()
-            cur.fetchall.return_value = []
-            conn.cursor.return_value.__enter__.return_value = cur
-            mock_connect.return_value = conn
-
-            store = PostgresStateStore("postgresql://test")
-            store.hybrid_search(
-                project_key="test-project",
-                repo_key=None,
-                query_text="test",
-                query_embedding=[0.1] * 128,
-            )
-
-            _, params = cur.execute.call_args[0]
-            assert params[1] is None  # repo_key should be None
-
-    def test_hybrid_search_default_parameters(self) -> None:
-        """hybrid_search should use default values for optional parameters."""
-        with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-            conn = MagicMock()
-            cur = MagicMock()
-            cur.fetchall.return_value = []
-            conn.cursor.return_value.__enter__.return_value = cur
-            mock_connect.return_value = conn
-
-            store = PostgresStateStore("postgresql://test")
-            store.hybrid_search(
-                project_key="test-project",
-                query_text="test",
-                query_embedding=[0.1] * 128,
-            )
-
-            _, params = cur.execute.call_args[0]
-            # Verify defaults: top_k=10, lexical_weight=0.4, vector_weight=0.6, snapshot_id=None
-            assert params[1] is None  # repo_key default
-            assert params[4] == 10  # top_k default
-            assert params[5] == 0.4  # lexical_weight default
-            assert params[6] == 0.6  # vector_weight default
-            assert params[7] is None  # snapshot_id default
-
-
-class TestHybridSearchWeightCombinations:
-    """Tests for various weight combinations in hybrid search."""
-
-    def test_lexical_only_weights(self) -> None:
-        """With lexical_weight=1.0, vector results should have zero contribution."""
-        with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-            conn = MagicMock()
-            cur = MagicMock()
-            cur.fetchall.return_value = []
-            conn.cursor.return_value.__enter__.return_value = cur
-            mock_connect.return_value = conn
-
-            store = PostgresStateStore("postgresql://test")
-            store.hybrid_search(
-                project_key="test-project",
-                query_text="test",
-                query_embedding=[0.1] * 128,
-                lexical_weight=1.0,
-                vector_weight=0.0,
-            )
-
-            _, params = cur.execute.call_args[0]
-            assert params[5] == 1.0
-            assert params[6] == 0.0
-
-    def test_vector_only_weights(self) -> None:
-        """With vector_weight=1.0, lexical results should have zero contribution."""
-        with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-            conn = MagicMock()
-            cur = MagicMock()
-            cur.fetchall.return_value = []
-            conn.cursor.return_value.__enter__.return_value = cur
-            mock_connect.return_value = conn
-
-            store = PostgresStateStore("postgresql://test")
-            store.hybrid_search(
-                project_key="test-project",
-                query_text="test",
-                query_embedding=[0.1] * 128,
-                lexical_weight=0.0,
-                vector_weight=1.0,
-            )
-
-            _, params = cur.execute.call_args[0]
-            assert params[5] == 0.0
-            assert params[6] == 1.0
-
-    def test_balanced_weights(self) -> None:
-        """With 0.5/0.5 weights, both retrieval methods should have equal contribution."""
-        with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-            conn = MagicMock()
-            cur = MagicMock()
-            cur.fetchall.return_value = []
-            conn.cursor.return_value.__enter__.return_value = cur
-            mock_connect.return_value = conn
-
-            store = PostgresStateStore("postgresql://test")
-            store.hybrid_search(
-                project_key="test-project",
-                query_text="test",
-                query_embedding=[0.1] * 128,
-                lexical_weight=0.5,
-                vector_weight=0.5,
-            )
-
-            _, params = cur.execute.call_args[0]
-            assert params[5] == 0.5
-            assert params[6] == 0.5
-
-
-class TestHybridSearchResultType:
-    """Tests for the HybridSearchResult TypedDict."""
-
-    def test_hybrid_search_result_has_required_fields(self) -> None:
-        """HybridSearchResult should have all required fields defined."""
-        # This is a compile-time check via TypedDict, but we verify the structure
-        expected_fields = {
-            "chunk_pk",
-            "document_id",
-            "chunk_id",
-            "content_text",
-            "source_uri",
-            "page_id",
-            "content_hash",
-            "metadata",
-            "lexical_rank",
-            "vector_rank",
-            "rrf_score",
-            "doc_class",
-            "page_title",
-            "source_type",
-            "space_key",
-        }
-        # TypedDict.__annotations__ contains the field definitions
-        actual_fields = set(HybridSearchResult.__annotations__.keys())
-        assert expected_fields == actual_fields
-
-
-class TestBootstrapFunctionsSql:
-    """Tests for SQL function definitions in _BOOTSTRAP_FUNCTIONS_SQL."""
-
-    def test_rrf_score_function_in_bootstrap_sql(self) -> None:
-        """_BOOTSTRAP_FUNCTIONS_SQL should contain rrf_score function definition."""
-        _BOOTSTRAP_FUNCTIONS_SQL = _SQUASH_SOURCE  # P4 / TSK-4.1.8 alias
-
-        assert "CREATE OR REPLACE FUNCTION audit_state.rrf_score" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "RETURNS NUMERIC" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "LANGUAGE SQL" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "IMMUTABLE" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "PARALLEL SAFE" in _BOOTSTRAP_FUNCTIONS_SQL
-
-    def test_hybrid_search_function_in_bootstrap_sql(self) -> None:
-        """_BOOTSTRAP_FUNCTIONS_SQL should contain hybrid_search function definition."""
-        _BOOTSTRAP_FUNCTIONS_SQL = _SQUASH_SOURCE  # P4 / TSK-4.1.8 alias
-
-        assert "CREATE OR REPLACE FUNCTION audit_state.hybrid_search" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "p_project_key TEXT" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "p_repo_key TEXT DEFAULT NULL" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "p_query_text TEXT" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "p_query_embedding vector" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "p_top_k INTEGER DEFAULT 10" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "p_lexical_weight NUMERIC DEFAULT 0.4" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "p_vector_weight NUMERIC DEFAULT 0.6" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "RETURNS TABLE" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "rrf_score NUMERIC" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "LANGUAGE plpgsql" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "STABLE" in _BOOTSTRAP_FUNCTIONS_SQL
-
-    def test_hybrid_search_uses_rrf_score_function(self) -> None:
-        """hybrid_search function should use rrf_score for fusion calculation."""
-        _BOOTSTRAP_FUNCTIONS_SQL = _SQUASH_SOURCE  # P4 / TSK-4.1.8 alias
-
-        # Verify that hybrid_search calls rrf_score
-        assert "audit_state.rrf_score(l.rank::INTEGER)" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "audit_state.rrf_score(v.rank::INTEGER)" in _BOOTSTRAP_FUNCTIONS_SQL
-
-    def test_hybrid_search_implements_full_outer_join(self) -> None:
-        """hybrid_search should use FULL OUTER JOIN for RRF fusion."""
-        _BOOTSTRAP_FUNCTIONS_SQL = _SQUASH_SOURCE  # P4 / TSK-4.1.8 alias
-
-        assert "FULL OUTER JOIN vector_results" in _BOOTSTRAP_FUNCTIONS_SQL
-
-    def test_hybrid_search_resolves_latest_snapshot(self) -> None:
-        """hybrid_search should resolve latest snapshot_id if not provided.
-
-        Snapshot priority: project_corpus (3) > default (2) > smoke_probe (1),
-        then by chunk_count DESC, changed_chunk_count DESC, created_at DESC.
-        """
-        _BOOTSTRAP_FUNCTIONS_SQL = _SQUASH_SOURCE  # P4 / TSK-4.1.8 alias
-
-        # Check for snapshot resolution logic
-        assert "IF v_snapshot_id IS NULL THEN" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "SELECT rs.id INTO v_snapshot_id" in _BOOTSTRAP_FUNCTIONS_SQL
-        # Priority-based ordering (not naive created_at DESC).
-        # NOTE: in the squash migration the SQL is rendered via op.execute()
-        # (no psycopg %-substitution), so the literal is a single `%`; the
-        # legacy BOOTSTRAP_SQL constant double-escaped to `%%`.
-        assert "WHEN lower(rs.snapshot_key) LIKE '%:project_corpus' THEN 3" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "COALESCE(rs.chunk_count, 0) DESC" in _BOOTSTRAP_FUNCTIONS_SQL
-
-    def test_advisory_lock_functions_in_bootstrap_sql(self) -> None:
-        """_BOOTSTRAP_FUNCTIONS_SQL should contain advisory lock functions."""
-        _BOOTSTRAP_FUNCTIONS_SQL = _SQUASH_SOURCE  # P4 / TSK-4.1.8 alias
-
-        assert "CREATE OR REPLACE FUNCTION audit_state.acquire_corpus_lock" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "CREATE OR REPLACE FUNCTION audit_state.acquire_repo_sync_lock" in _BOOTSTRAP_FUNCTIONS_SQL
-        assert "pg_try_advisory_xact_lock" in _BOOTSTRAP_FUNCTIONS_SQL

package/tools/vds-scripts/audit_orchestrator/tests/unit/state/test_normalize_url.py

@@ -1,262 +0,0 @@
-"""Unit tests for normalize_url utility function (TSK-471.1.6)."""
-
-from vds_audit_orchestrator.state.store import normalize_url
-
-
-class TestNormalizeUrlEmptyAndNone:
-    """Tests for empty/None input handling."""
-
-    def test_none_input_returns_empty_string(self) -> None:
-        """None should return empty string."""
-        assert normalize_url(None) == ""
-
-    def test_empty_string_returns_empty_string(self) -> None:
-        """Empty string should return empty string."""
-        assert normalize_url("") == ""
-
-    def test_whitespace_only_returns_empty_string(self) -> None:
-        """Whitespace-only string should return empty string."""
-        assert normalize_url("   ") == ""
-        assert normalize_url("\t\n") == ""
-
-    def test_whitespace_is_trimmed(self) -> None:
-        """Leading/trailing whitespace should be trimmed."""
-        assert normalize_url("  https://example.com  ") == "https://example.com"
-
-
-class TestNormalizeUrlSchemeAndHost:
-    """Tests for Rule 1: Lowercase scheme and host."""
-
-    def test_uppercase_scheme_normalized(self) -> None:
-        """Uppercase HTTP should be normalized to lowercase."""
-        assert normalize_url("HTTP://example.com/path") == "http://example.com/path"
-
-    def test_uppercase_https_normalized(self) -> None:
-        """Uppercase HTTPS should be normalized to lowercase."""
-        assert normalize_url("HTTPS://EXAMPLE.COM/PATH") == "https://example.com/PATH"
-
-    def test_mixed_case_host_normalized(self) -> None:
-        """Mixed case host should be normalized to lowercase."""
-        assert normalize_url("https://Example.Com/path") == "https://example.com/path"
-
-    def test_scheme_and_host_both_normalized(self) -> None:
-        """Both scheme and host should be lowercase."""
-        assert normalize_url("HtTpS://ExAmPlE.CoM/Path") == "https://example.com/Path"
-
-
-class TestNormalizeUrlDefaultPorts:
-    """Tests for Rule 3: Remove default ports."""
-
-    def test_http_port_80_removed(self) -> None:
-        """Port :80 should be removed for http scheme."""
-        assert normalize_url("http://example.com:80/path") == "http://example.com/path"
-
-    def test_https_port_443_removed(self) -> None:
-        """Port :443 should be removed for https scheme."""
-        assert normalize_url("https://example.com:443/path") == "https://example.com/path"
-
-    def test_http_non_standard_port_preserved(self) -> None:
-        """Non-standard port :8080 should be preserved."""
-        assert normalize_url("http://example.com:8080/path") == "http://example.com:8080/path"
-
-    def test_https_non_standard_port_preserved(self) -> None:
-        """Non-standard port :8443 should be preserved."""
-        assert normalize_url("https://example.com:8443/path") == "https://example.com:8443/path"
-
-    def test_port_80_with_uppercase_host(self) -> None:
-        """Port removal should work with case normalization."""
-        assert normalize_url("HTTP://EXAMPLE.COM:80/path") == "http://example.com/path"
-
-    def test_port_443_with_uppercase_host(self) -> None:
-        """Port removal should work with case normalization."""
-        assert normalize_url("HTTPS://EXAMPLE.COM:443/path") == "https://example.com/path"
-
-
-class TestNormalizeUrlTrailingSlashes:
-    """Tests for Rule 2: Strip trailing slashes from path."""
-
-    def test_single_trailing_slash_removed(self) -> None:
-        """Single trailing slash should be removed."""
-        assert normalize_url("https://example.com/path/") == "https://example.com/path"
-
-    def test_multiple_trailing_slashes_removed(self) -> None:
-        """Multiple trailing slashes should be removed."""
-        assert normalize_url("https://example.com/path///") == "https://example.com/path"
-
-    def test_root_path_returns_empty_path(self) -> None:
-        """Root path with slash should return empty path."""
-        assert normalize_url("https://example.com/") == "https://example.com"
-
-    def test_no_trailing_slash_unchanged(self) -> None:
-        """URL without trailing slash should be unchanged (except case)."""
-        assert normalize_url("https://example.com/path") == "https://example.com/path"
-
-    def test_path_with_query_trailing_slash_preserved(self) -> None:
-        """Trailing slash before query string is preserved (path component)."""
-        # The function strips trailing slashes from the final URL, not from path before query
-        assert normalize_url("https://example.com/path/?q=1") == "https://example.com/path/?q=1"
-
-
-class TestNormalizeUrlQueryParameters:
-    """Tests for Rule 4: Sort query parameters alphabetically."""
-
-    def test_query_params_sorted_alphabetically(self) -> None:
-        """Query parameters should be sorted alphabetically by key."""
-        assert normalize_url("https://example.com?z=1&a=2&m=3") == "https://example.com?a=2&m=3&z=1"
-
-    def test_multiple_same_keys_preserved(self) -> None:
-        """Multiple parameters with same key should be preserved."""
-        result = normalize_url("https://example.com?b=2&a=1&b=3")
-        # a should come before b, both b's should be preserved
-        assert result.startswith("https://example.com?a=1&")
-        assert "b=2" in result
-        assert "b=3" in result
-
-    def test_empty_query_value_preserved(self) -> None:
-        """Empty query values should be preserved."""
-        assert normalize_url("https://example.com?b=&a=value") == "https://example.com?a=value&b="
-
-    def test_no_query_unchanged(self) -> None:
-        """URL without query string should be unchanged."""
-        assert normalize_url("https://example.com/path") == "https://example.com/path"
-
-    def test_query_with_special_chars(self) -> None:
-        """Query with encoded special characters should work."""
-        result = normalize_url("https://example.com?c=%20&a=test")
-        assert "a=test" in result
-        assert "c=" in result
-
-
-class TestNormalizeUrlFragments:
-    """Tests for Rule 5: Strip fragments."""
-
-    def test_fragment_removed(self) -> None:
-        """Fragment should be removed."""
-        assert normalize_url("https://example.com/path#section") == "https://example.com/path"
-
-    def test_fragment_with_query_removed(self) -> None:
-        """Fragment should be removed even with query string."""
-        assert normalize_url("https://example.com/path?q=1#section") == "https://example.com/path?q=1"
-
-    def test_only_fragment_removed(self) -> None:
-        """Only fragment should be removed when no other parts."""
-        assert normalize_url("https://example.com#anchor") == "https://example.com"
-
-
-class TestNormalizeUrlPercentEncoding:
-    """Tests for Rule 6: Decode unnecessary percent-encoding."""
-
-    def test_encoded_space_decoded(self) -> None:
-        """Encoded space (%20) should be decoded in path."""
-        assert normalize_url("https://example.com/path%20with%20spaces") == "https://example.com/path with spaces"
-
-    def test_encoded_unreserved_chars_decoded(self) -> None:
-        """Encoded unreserved characters should be decoded."""
-        assert normalize_url("https://example.com/path%2Dtest") == "https://example.com/path-test"
-
-    def test_path_encoding_preserved_for_reserved(self) -> None:
-        """Reserved characters in path may remain encoded as needed."""
-        # The actual behavior depends on urlunparse behavior
-        result = normalize_url("https://example.com/path%2Fsegment")
-        # Should handle gracefully
-        assert "example.com" in result
-
-
-class TestNormalizeUrlRelativeUrls:
-    """Tests for relative URLs (no scheme)."""
-
-    def test_relative_url_returned_stripped(self) -> None:
-        """Relative URL should have trailing slash stripped."""
-        assert normalize_url("/path/to/resource/") == "/path/to/resource"
-
-    def test_relative_url_without_slash_unchanged(self) -> None:
-        """Relative URL without trailing slash should be unchanged."""
-        assert normalize_url("/path/to/resource") == "/path/to/resource"
-
-    def test_relative_url_with_fragment_returned(self) -> None:
-        """Relative URL with fragment should be returned as-is (stripped)."""
-        # Note: For relative URLs, we just strip trailing slashes, no parsing
-        assert normalize_url("/path/#anchor") == "/path/#anchor"
-
-    def test_relative_url_with_query_returned(self) -> None:
-        """Relative URL with query should be returned as-is (stripped)."""
-        assert normalize_url("/path/?q=1") == "/path/?q=1"
-
-
-class TestNormalizeUrlEdgeCases:
-    """Tests for edge cases and error handling."""
-
-    def test_complex_url_all_rules_applied(self) -> None:
-        """All normalization rules should be applied together."""
-        result = normalize_url("HTTPS://EXAMPLE.COM:443/Path/To/Resource/?z=last&a=first#anchor")
-        # Trailing slash before query is preserved, but final trailing slash and fragment removed
-        assert result == "https://example.com/Path/To/Resource/?a=first&z=last"
-
-    def test_domain_with_subdomain(self) -> None:
-        """Subdomain should be lowercased but preserved."""
-        assert normalize_url("https://WWW.Example.COM/path") == "https://www.example.com/path"
-
-    def test_ip_address_host(self) -> None:
-        """IP address should be handled correctly."""
-        assert normalize_url("https://192.168.1.1:443/path") == "https://192.168.1.1/path"
-
-    def test_ipv6_address_host(self) -> None:
-        """IPv6 address should be handled."""
-        # IPv6 addresses have brackets
-        result = normalize_url("https://[::1]:443/path")
-        assert result == "https://[::1]/path"
-
-    def test_url_with_username_no_password(self) -> None:
-        """URL with username should be preserved."""
-        result = normalize_url("https://user@example.com/path")
-        assert "user@example.com" in result
-
-    def test_url_with_credentials(self) -> None:
-        """URL with username and password should be preserved."""
-        result = normalize_url("https://user:pass@EXAMPLE.COM/path")
-        assert "user:pass@example.com" in result
-
-    def test_long_url_handled(self) -> None:
-        """Long URLs should be handled without issues."""
-        long_path = "/a" * 100
-        url = f"https://example.com{long_path}"
-        result = normalize_url(url)
-        assert result.startswith("https://example.com")
-
-    def test_unicode_domain(self) -> None:
-        """Unicode in domain should be handled (Punycode not converted)."""
-        # urlparse handles Unicode domains
-        result = normalize_url("https://例え.jp/path")
-        assert result.endswith("/path") or result == "https://例え.jp/path"
-
-    def test_ftp_scheme_not_supported(self) -> None:
-        """Non-HTTP schemes should be returned as-is (relative URL handling)."""
-        # Since we only handle http/https, other schemes are treated as relative
-        assert normalize_url("ftp://example.com/file") == "ftp://example.com/file"
-
-
-class TestNormalizeUrlDeduplication:
-    """Tests demonstrating URL deduplication use case."""
-
-    def test_equivalent_urls_normalize_same(self) -> None:
-        """Multiple equivalent URLs should normalize to the same value."""
-        urls = [
-            "HTTPS://EXAMPLE.COM:443/path",
-            "https://example.com/path/",
-            "https://Example.Com/path",
-            "https://example.com:443/path",
-        ]
-        normalized = {normalize_url(url) for url in urls}
-        assert normalized == {"https://example.com/path"}
-
-    def test_different_urls_normalize_different(self) -> None:
-        """Different URLs should not normalize to the same value."""
-        url1 = normalize_url("https://example.com/page1")
-        url2 = normalize_url("https://example.com/page2")
-        assert url1 != url2
-
-    def test_query_order_irrelevant_for_dedup(self) -> None:
-        """Different query parameter order should normalize to same URL."""
-        url1 = normalize_url("https://example.com?b=2&a=1")
-        url2 = normalize_url("https://example.com?a=1&b=2")
-        assert url1 == url2