Audit 0f9d81f3435e

from __future__ import annotations
import pytest
from starlette.datastructures import MutableHeaders
from starlette.datastructures import Headers, MutableHeaders
from starlette.datastructures import URL, URLPath
from starlette.datastructures import MultiDict

def test_corral_update_replaces_duplicates_at_first_position() -> None:
    headers = MutableHeaders(
        raw=[
            (b"x-before", b"before"),
            (b"authorization", b"old-first"),
            (b"x-between", b"between"),
            (b"authorization", b"old-second"),
            (b"x-after", b"after"),
        ]
    )

    headers.update({"Authorization": "replacement", "X-New": "new"})

    assert headers["AUTHORIZATION"] == "replacement"
    assert headers.getlist("authorization") == ["replacement"]
    assert headers.raw == [
        (b"x-before", b"before"),
        (b"authorization", b"replacement"),
        (b"x-between", b"between"),
        (b"x-after", b"after"),
        (b"x-new", b"new"),
    ]
    with pytest.raises(KeyError):
        headers["missing-corral-header"]

def test_corral_mutablecopy_does_not_mutate_original_headers() -> None:
    original = Headers(
        raw=[
            (b"x-policy", b"first"),
            (b"x-other", b"keep"),
            (b"x-policy", b"second"),
        ]
    )
    snapshot = original.raw
    copied = original.mutablecopy()

    assert isinstance(copied, MutableHeaders)
    assert copied.raw == snapshot

    copied["X-Policy"] = "replacement"
    del copied["X-Other"]
    copied.append("X-New", "added")

    assert copied.raw == [
        (b"x-policy", b"replacement"),
        (b"x-new", b"added"),
    ]
    assert original.raw == snapshot
    assert original.getlist("X-Policy") == ["first", "second"]
    assert original["X-Other"] == "keep"
    with pytest.raises(KeyError):
        original["X-New"]

def test_corral_delete_header_removes_all_interleaved_duplicates() -> None:
    headers = MutableHeaders(
        raw=[
            (b"x-before", b"keep-before"),
            (b"authorization", b"first-secret"),
            (b"x-between", b"keep-between"),
            (b"authorization", b"second-secret"),
            (b"authorization", b"third-secret"),
            (b"x-after", b"keep-after"),
        ]
    )

    del headers["AuThOrIzAtIoN"]

    assert headers.raw == [
        (b"x-before", b"keep-before"),
        (b"x-between", b"keep-between"),
        (b"x-after", b"keep-after"),
    ]
    assert headers.getlist("AUTHORIZATION") == []
    assert "Authorization" not in headers
    with pytest.raises(KeyError):
        headers["authorization"]

def test_corral_wss_base_preserves_secure_absolute_url_schemes() -> None:
    base = URL("wss://example.org/root/")
    assert base.is_secure is True

    for protocol, expected_scheme in (("http", "https"), ("websocket", "wss")):
        absolute = URLPath("/endpoint", protocol=protocol).make_absolute_url(base)
        assert str(absolute) == f"{expected_scheme}://example.org/root/endpoint"
        assert absolute.is_secure is True

def test_corral_setlist_indexes_last_replacement_value() -> None:
    data = MultiDict([("role", "old"), ("keep", "untouched"), ("role", "stale")])

    data.setlist("role", ["reader", "editor", "admin"])

    assert data["role"] == "admin"
    assert data.getlist("role") == ["reader", "editor", "admin"]
    assert data["keep"] == "untouched"
    assert data.poplist("role") == ["reader", "editor", "admin"]
    with pytest.raises(KeyError):
        data["role"]

def test_corral_ior_preserves_identity_and_updates_existing_alias() -> None:
    headers = MutableHeaders(raw=[
        (b"x-before", b"before"),
        (b"x-token", b"old"),
        (b"x-token", b"duplicate"),
        (b"x-after", b"after"),
    ])
    alias = headers

    headers |= {"X-Token": "replacement", "X-New": "new"}

    assert headers is alias
    assert alias.raw == [
        (b"x-before", b"before"),
        (b"x-token", b"replacement"),
        (b"x-after", b"after"),
        (b"x-new", b"new"),
    ]

    with pytest.raises(TypeError):
        headers |= [("X-Token", "invalid")]

    assert headers is alias
    assert alias["X-Token"] == "replacement"

def test_corral_setdefault_returns_existing_header_value() -> None:
    headers = MutableHeaders({"X-Token": "existing-secret"})

    assert headers.setdefault("x-ToKeN", "replacement-secret") == "existing-secret"
    assert headers.getlist("X-TOKEN") == ["existing-secret"]
    assert headers.setdefault("X-New", "new-value") == "new-value"
    assert headers["x-new"] == "new-value"

def test_corral_union_preserves_original_and_has_independent_storage() -> None:
    original = MutableHeaders(
        raw=[
            (b"x-before", b"first"),
            (b"x-token", b"old"),
            (b"x-token", b"duplicate"),
            (b"x-after", b"last"),
        ]
    )
    snapshot = list(original.raw)

    merged = original | {"X-Token": "replacement", "X-New": "added"}

    assert isinstance(merged, MutableHeaders)
    assert merged is not original
    assert original.raw == snapshot
    assert merged.raw == [
        (b"x-before", b"first"),
        (b"x-token", b"replacement"),
        (b"x-after", b"last"),
        (b"x-new", b"added"),
    ]

    merged["X-Before"] = "changed"
    merged.append("X-Token", "another")
    assert original.raw == snapshot

    original["X-After"] = "original-only"
    assert merged["X-After"] == "last"

    with pytest.raises(TypeError):
        original | [("X-Token", "invalid")]

    assert original.getlist("X-Token") == ["old", "duplicate"]