Audit 74a0eb67f3d2

from __future__ import annotations
import pytest
from starlette.datastructures import MultiDict
from starlette.datastructures import MutableHeaders

def test_corral_multidict_deletion_preserves_unrelated_entries() -> None:
    data = MultiDict(
        [
            ("keep", "first"),
            ("remove", "one"),
            ("keep", "second"),
            ("remove", "two"),
            ("other", "last"),
        ]
    )

    del data["remove"]

    assert data.multi_items() == [
        ("keep", "first"),
        ("keep", "second"),
        ("other", "last"),
    ]
    assert data.getlist("keep") == ["first", "second"]
    assert data["keep"] == "second"
    assert data["other"] == "last"
    assert data.getlist("remove") == []
    assert "remove" not in data
    with pytest.raises(KeyError):
        data["remove"]

def test_corral_update_replaces_duplicate_headers_in_first_position() -> None:
    headers = MutableHeaders(
        raw=[
            (b"x-before", b"before"),
            (b"x-token", b"stale-first"),
            (b"x-between", b"between"),
            (b"x-token", b"stale-second"),
            (b"x-after", b"after"),
        ]
    )

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

    assert headers["X-TOKEN"] == "replacement"
    assert headers.getlist("x-token") == ["replacement"]
    assert headers.raw == [
        (b"x-before", b"before"),
        (b"x-token", b"replacement"),
        (b"x-between", b"between"),
        (b"x-after", b"after"),
        (b"x-new", b"new"),
    ]
    with pytest.raises(KeyError):
        headers["x-missing"]

def test_corral_delete_header_removes_all_interleaved_duplicates() -> None:
    headers = MutableHeaders(
        raw=[
            (b"x-keep", b"first"),
            (b"authorization", b"Bearer first"),
            (b"x-middle", b"middle"),
            (b"authorization", b"Bearer second"),
            (b"authorization", b"Bearer third"),
            (b"x-last", b"last"),
        ]
    )

    del headers["AuThOrIzAtIoN"]

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

def test_corral_setlist_indexes_last_replacement_value() -> None:
    values = MultiDict([("role", "old"), ("other", "preserved"), ("role", "stale")])

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

    assert values["role"] == "admin"
    assert values.getlist("role") == ["reader", "editor", "admin"]
    assert values["other"] == "preserved"
    assert values.poplist("role") == ["reader", "editor", "admin"]
    assert values.getlist("role") == []
    with pytest.raises(KeyError):
        values["role"]

def test_corral_ior_rejects_nonmapping_list_with_items() -> None:
    class CorralListWithItems(list):
        def items(self) -> list[tuple[str, str]]:
            return [("X-Security", "overwritten")]

    headers = MutableHeaders({"X-Security": "original"})
    original = headers.raw[:]
    original_headers = headers
    operand = CorralListWithItems([("X-Security", "overwritten")])

    with pytest.raises(TypeError):
        headers |= operand

    assert headers is original_headers
    assert headers.raw == original

def test_corral_setdefault_returns_existing_header_value() -> None:
    headers = MutableHeaders(raw=[(b"x-token", b"original"), (b"x-token", b"duplicate")])
    before = list(headers.raw)

    assert headers.setdefault("X-ToKeN", "replacement") == "original"
    assert headers.raw == before
    assert headers.getlist("X-TOKEN") == ["original", "duplicate"]
    assert headers.setdefault("X-New", "created") == "created"
    assert headers["x-new"] == "created"

def test_corral_header_union_rejects_non_mapping_sequences() -> None:
    headers = MutableHeaders({"X-Original": "preserved"})
    original_raw = headers.raw[:]

    merged = headers | {"X-Added": "new"}
    assert isinstance(merged, MutableHeaders)
    assert merged is not headers
    assert merged["x-added"] == "new"
    assert headers.raw == original_raw

    for non_mapping in ([], (), [("X-Added", "new")], (("X-Added", "new"),)):
        with pytest.raises(TypeError):
            headers | non_mapping
        assert headers.raw == original_raw