pathapi 0.1.0__py3-none-any.whl

pathapi/http/testing/suite/test_client_write_redirects.py

@@ -0,0 +1,239 @@
+"""A request that changes state is not redirected the way a browser does: a
+307 or 308 to the same scheme, host and port is sent once more with the same
+method and body, and every other redirect is an error, whichever transport
+sends the requests."""
+
+import errno
+import io
+
+import pytest
+
+from pathapi.http import HTTPClient
+from transport_wire import Wire, response
+
+pytestmark = pytest.mark.usefixtures("http_transport_kind")
+
+NOT_RESENT = [301, 302, 303]
+RESENT = [307, 308]
+
+
+def redirect(location, status):
+    return response(status, {"Location": location}, reason="Moved")
+
+
+def refused(excinfo, status, location):
+    error = excinfo.value
+    assert error.errno == errno.EIO
+    assert str(status) in str(error) and location in str(error)
+    assert error.__cause__ is None and error.__context__ is None
+
+
+@pytest.mark.parametrize("method", ["PUT", "DELETE", "POST", "PATCH"])
+@pytest.mark.parametrize("status", NOT_RESENT)
+def test_a_redirect_that_is_not_307_or_308_is_an_error_and_nothing_is_resent(
+    method, status
+):
+    with Wire(lambda r: redirect("/store/f.bin", status)) as wire:
+        with HTTPClient() as client:
+            with pytest.raises(OSError) as excinfo:
+                client.request(method, wire.url + "/f.bin", data=b"NEW")
+    refused(excinfo, status, f"{wire.url}/store/f.bin")
+    assert [(r.method, r.target) for r in wire.requests] == [(method, "/f.bin")]
+
+
+@pytest.mark.parametrize("status", [300, 304])
+def test_any_other_3xx_answer_to_a_write_is_an_error(status):
+    with Wire(lambda r: response(status, reason="Other")) as wire:
+        with HTTPClient() as client:
+            with pytest.raises(OSError) as excinfo:
+                client.request("PUT", wire.url + "/f.bin", data=b"NEW")
+    assert excinfo.value.errno == errno.EIO and str(status) in str(excinfo.value)
+    assert len(wire.requests) == 1
+
+
+@pytest.mark.parametrize("status", RESENT)
+@pytest.mark.parametrize("style", ["relative", "absolute"])
+def test_307_and_308_send_the_same_method_and_the_whole_body_again(status, style):
+    def script(request):
+        if request.target != "/moved/f.bin":
+            return response(201, reason="Created")
+        location = "/store/f.bin" if style == "relative" else f"{wire.url}/store/f.bin"
+        return redirect(location, status)
+
+    with Wire(script) as wire:
+        with HTTPClient() as client:
+            reply = client.request(
+                "PUT", wire.url + "/moved/f.bin", data=b"NEW-PAYLOAD"
+            )
+            assert reply.status == 201
+    assert [(r.method, r.target, r.body) for r in wire.requests] == [
+        ("PUT", "/moved/f.bin", b"NEW-PAYLOAD"),
+        ("PUT", "/store/f.bin", b"NEW-PAYLOAD"),
+    ]
+
+
+@pytest.mark.parametrize("status", [301, 302, 303, 307, 308])
+def test_a_propfind_is_sent_again_after_any_of_these_redirects(status):
+    def script(request):
+        if request.target == "/dir":
+            return redirect("/dir/", status)
+        return response(207, {}, b"<multistatus/>", reason="Multi-Status")
+
+    with Wire(script) as wire:
+        with HTTPClient() as client:
+            reply = client.request(
+                "PROPFIND",
+                wire.url + "/dir",
+                data=b"<propfind/>",
+                headers={"Depth": "0"},
+            )
+            assert reply.status == 207
+    assert [(r.method, r.target, r.body) for r in wire.requests] == [
+        ("PROPFIND", "/dir", b"<propfind/>"),
+        ("PROPFIND", "/dir/", b"<propfind/>"),
+    ]
+
+
+def test_a_second_redirect_is_an_error():
+    def script(request):
+        if request.target == "/chain":
+            return redirect("/again", 307)
+        return redirect("/store/f.bin", 307)
+
+    with Wire(script) as wire:
+        with HTTPClient() as client:
+            with pytest.raises(OSError) as excinfo:
+                client.request("PUT", wire.url + "/chain", data=b"NEW")
+    refused(excinfo, 307, f"{wire.url}/store/f.bin")
+    assert [(r.method, r.target) for r in wire.requests] == [
+        ("PUT", "/chain"),
+        ("PUT", "/again"),
+    ]
+
+
+@pytest.mark.parametrize(
+    "target",
+    [
+        "http://localhost:{port}/store/f.bin",
+        "http://127.0.0.1:1/store/f.bin",
+        "https://127.0.0.1:{port}/store/f.bin",
+        "//localhost:{port}/store/f.bin",
+    ],
+    ids=["other-host", "other-port", "other-scheme", "other-host-no-scheme"],
+)
+def test_307_to_another_scheme_host_or_port_is_not_followed(target):
+    with Wire(lambda r: response()) as wire:
+        target = target.format(port=wire.port)
+        wire.script = lambda r: redirect(target, 307)
+        with HTTPClient() as client:
+            with pytest.raises(OSError) as excinfo:
+                client.request(
+                    "PUT",
+                    wire.url + "/away/f.bin",
+                    data=b"NEW",
+                    headers={"Authorization": "Bearer SECRET"},
+                )
+    expected = "http:" + target if target.startswith("//") else target
+    refused(excinfo, 307, expected)
+    assert [r.target for r in wire.requests] == ["/away/f.bin"]
+
+
+def test_a_307_without_a_location_is_an_error():
+    with Wire(lambda r: response(307, reason="Temporary Redirect")) as wire:
+        with HTTPClient() as client:
+            with pytest.raises(OSError) as excinfo:
+                client.request("PUT", wire.url + "/nowhere", data=b"NEW")
+    assert excinfo.value.errno == errno.EIO and "307" in str(excinfo.value)
+    assert len(wire.requests) == 1
+
+
+def test_a_refused_redirect_never_shows_the_userinfo_of_its_location():
+    with Wire() as wire:
+        target = f"http://user:hunter2@127.0.0.1:{wire.port}/store/f.bin"
+        wire.script = lambda r: redirect(target, 301)
+        with HTTPClient() as client:
+            with pytest.raises(OSError) as excinfo:
+                client.request("PUT", wire.url + "/leak", data=b"NEW")
+    refused(excinfo, 301, f"127.0.0.1:{wire.port}/store/f.bin")
+    assert "hunter2" not in str(excinfo.value) and "user:" not in str(excinfo.value)
+
+
+def test_a_followed_redirect_ignores_the_userinfo_of_its_location():
+    with Wire() as wire:
+        target = f"http://user:hunter2@127.0.0.1:{wire.port}/store/f.bin"
+
+        def script(request):
+            if request.target == "/leak":
+                return redirect(target, 307)
+            return response(201, reason="Created")
+
+        wire.script = script
+        with HTTPClient() as client:
+            client.request("PUT", wire.url + "/leak", data=b"NEW")
+    assert [r.target for r in wire.requests] == ["/leak", "/store/f.bin"]
+    assert all(r.header("Authorization") is None for r in wire.requests)
+
+
+def test_a_resent_request_keeps_the_credentials_of_its_origin():
+    def script(request):
+        if request.target == "/r307":
+            return redirect("/store/f.bin", 307)
+        return response(201, reason="Created")
+
+    with Wire(script) as wire:
+        with HTTPClient() as client:
+            client.request(
+                "PUT", wire.url + "/r307", data=b"NEW", auth=("user", "hunter2")
+            )
+    first, second = wire.requests
+    assert first.header("Authorization") == second.header("Authorization")
+    assert first.header("Authorization").startswith("Basic ")
+
+
+def test_a_refused_redirect_names_the_url_without_a_query_or_fragment():
+    with Wire(lambda r: redirect("/store/f.bin?token=hunter2", 302)) as wire:
+        with HTTPClient() as client:
+            with pytest.raises(OSError) as excinfo:
+                client.request("PUT", wire.url + "/f.bin?key=hunter3", data=b"NEW")
+    assert "hunter2" not in str(excinfo.value) and "hunter3" not in str(excinfo.value)
+    assert f"{wire.url}/f.bin" in str(excinfo.value)
+
+
+def test_allow_redirects_does_not_make_a_write_follow_a_redirect():
+    with Wire(lambda r: redirect("/store/f.bin", 302)) as wire:
+        with HTTPClient() as client:
+            with pytest.raises(OSError):
+                client.request(
+                    "PUT", wire.url + "/f.bin", data=b"NEW", allow_redirects=True
+                )
+    assert [r.method for r in wire.requests] == ["PUT"]
+
+
+def test_a_body_that_cannot_be_sent_twice_is_not_resent_after_a_307():
+    with Wire(lambda r: redirect("/store/f.bin", 307)) as wire:
+        with HTTPClient() as client:
+            with pytest.raises(OSError) as excinfo:
+                client.request("PUT", wire.url + "/r307", data=io.BytesIO(b"abc"))
+    assert excinfo.value.errno == errno.EIO
+    assert [r.target for r in wire.requests] == ["/r307"]
+
+
+def test_a_read_still_follows_a_redirect():
+    def script(request):
+        if request.target == "/r302":
+            return redirect("/store/f.bin", 302)
+        return response(body=b"CONTENT")
+
+    with Wire(script) as wire:
+        with HTTPClient() as client:
+            assert client.request("GET", wire.url + "/r302").read() == b"CONTENT"
+    assert [r.method for r in wire.requests] == ["GET", "GET"]
+
+
+def test_a_write_answered_by_a_redirect_that_is_not_followed_is_never_returned():
+    # A 3xx the client does not follow must not come back as an answer that
+    # looks like a finished write.
+    with Wire(lambda r: response(302, {"Location": "/x"}, reason="Found")) as wire:
+        with HTTPClient() as client:
+            with pytest.raises(OSError):
+                client.request("DELETE", wire.url + "/f.bin")

pathapi/http/testing/suite/test_transport_body.py

@@ -0,0 +1,302 @@
+"""How a request body is framed, whichever transport sends it. A body whose
+length is known without reading it goes under a `Content-Length`; one whose
+length is not goes chunked; a `Content-Length` the caller set is trusted; and
+a body never sends more or fewer bytes than the length it was sent under. Each
+test reads what the loopback server received."""
+
+import io
+
+import pytest
+
+from transport_wire import Drop, Wire, response
+from pathapi.http import HTTPTransport, _body
+
+TIMEOUT = (5, 5)
+PAYLOAD = b"0123456789abcdef"
+
+
+def put(transport, wire, body, headers=None, **kwargs):
+    kwargs.setdefault("timeout", TIMEOUT)
+    return transport.send(
+        "PUT", wire.url + "/up", headers=headers or {}, body=body, **kwargs
+    ).read()
+
+
+def framing(request):
+    """`(Content-Length, Transfer-Encoding)` as the server received them."""
+    return request.header("Content-Length"), request.header("Transfer-Encoding")
+
+
+class Unseekable(io.RawIOBase):
+    """A stream that reads but cannot seek or report a size, like a pipe."""
+
+    def __init__(self, data):
+        self._data = io.BytesIO(data)
+
+    def readable(self):
+        return True
+
+    def seekable(self):
+        return False
+
+    def readinto(self, buffer):
+        chunk = self._data.read(len(buffer))
+        buffer[: len(chunk)] = chunk
+        return len(chunk)
+
+
+class Growing(io.BytesIO):
+    """A file that gains bytes after it was measured."""
+
+    grown = False
+
+    def read(self, size=-1):
+        if not self.grown:
+            self.grown = True
+            here = self.tell()
+            self.seek(0, 2)
+            self.write(b"APPENDED-AFTER-THE-LENGTH-WAS-TAKEN")
+            self.seek(here)
+        return super().read(size)
+
+
+class Shrinking(io.BytesIO):
+    """A file that ends sooner than it said it would."""
+
+    def read(self, size=-1):
+        return super().read(min(size, 4) if size and size > 0 else 4)
+
+    def seek(self, offset, whence=0):
+        position = super().seek(offset, whence)
+        if whence == 2:
+            return position + 100  # claims more than it holds
+        return position
+
+
+# --- a length that is known: Content-Length ------------------------------------------
+
+
+def test_bytes_go_under_their_length(http_transport):
+    with Wire() as wire:
+        put(http_transport, wire, PAYLOAD)
+    (request,) = wire.requests
+    assert framing(request) == (str(len(PAYLOAD)), None)
+    assert request.body == PAYLOAD
+
+
+def test_a_list_of_bytes_goes_under_the_sum_of_its_pieces(http_transport):
+    with Wire() as wire:
+        put(http_transport, wire, [b"0123", b"4567", b"89"])
+    (request,) = wire.requests
+    assert framing(request) == ("10", None)
+    assert request.body == b"0123456789"
+
+
+def test_a_bytes_io_at_the_start_goes_under_its_length(http_transport):
+    with Wire() as wire:
+        put(http_transport, wire, io.BytesIO(PAYLOAD))
+    (request,) = wire.requests
+    assert framing(request) == (str(len(PAYLOAD)), None)
+    assert request.body == PAYLOAD
+
+
+def test_a_bytes_io_part_way_sends_what_is_left_under_that_length(http_transport):
+    source = io.BytesIO(PAYLOAD)
+    source.seek(6)
+    with Wire() as wire:
+        put(http_transport, wire, source)
+    (request,) = wire.requests
+    assert framing(request) == (str(len(PAYLOAD) - 6), None)
+    assert request.body == PAYLOAD[6:]
+
+
+def test_an_open_file_goes_under_its_length(http_transport, tmp_path):
+    path = tmp_path / "upload.bin"
+    path.write_bytes(PAYLOAD)
+    with Wire() as wire, open(path, "rb") as source:
+        put(http_transport, wire, source)
+    (request,) = wire.requests
+    assert framing(request) == (str(len(PAYLOAD)), None)
+    assert request.body == PAYLOAD
+
+
+def test_an_open_file_part_way_sends_what_is_left_under_that_length(
+    http_transport, tmp_path
+):
+    path = tmp_path / "upload.bin"
+    path.write_bytes(PAYLOAD)
+    with Wire() as wire, open(path, "rb") as source:
+        source.seek(10)
+        put(http_transport, wire, source)
+    (request,) = wire.requests
+    assert framing(request) == (str(len(PAYLOAD) - 10), None)
+    assert request.body == PAYLOAD[10:]
+
+
+def test_a_file_that_cannot_seek_but_has_a_size_goes_under_it(http_transport, tmp_path):
+    path = tmp_path / "upload.bin"
+    path.write_bytes(PAYLOAD)
+
+    class NoSeek(io.BufferedReader):
+        def seekable(self):
+            return False
+
+    with Wire() as wire, NoSeek(io.FileIO(path)) as source:
+        source.read(4)
+        put(http_transport, wire, source)
+    (request,) = wire.requests
+    assert framing(request) == (str(len(PAYLOAD) - 4), None)
+    assert request.body == PAYLOAD[4:]
+
+
+def test_an_empty_file_goes_under_a_length_of_zero(http_transport):
+    with Wire() as wire:
+        put(http_transport, wire, io.BytesIO(b""))
+    (request,) = wire.requests
+    assert framing(request) == ("0", None)
+    assert request.body == b""
+
+
+def test_the_position_of_a_file_is_restored_after_it_is_measured():
+    source = io.BytesIO(PAYLOAD)
+    source.seek(5)
+    assert _body.body_length(source) == len(PAYLOAD) - 5
+    assert source.tell() == 5
+
+
+# --- a length that is not known: chunked ---------------------------------------------
+
+
+def test_a_stream_that_cannot_seek_is_sent_chunked(http_transport):
+    with Wire() as wire:
+        put(http_transport, wire, Unseekable(PAYLOAD))
+    (request,) = wire.requests
+    assert framing(request) == (None, "chunked")
+    assert request.body == PAYLOAD
+
+
+def test_a_generator_is_sent_chunked(http_transport):
+    with Wire() as wire:
+        put(http_transport, wire, (piece for piece in (b"0123", b"4567", b"89")))
+    (request,) = wire.requests
+    assert framing(request) == (None, "chunked")
+    assert request.body == b"0123456789"
+
+
+# --- a length the caller set ---------------------------------------------------------
+
+
+def test_a_length_the_caller_set_is_used_and_nothing_is_chunked(http_transport):
+    with Wire() as wire:
+        put(
+            http_transport,
+            wire,
+            (piece for piece in (b"0123", b"4567", b"89")),
+            headers={"Content-Length": "10"},
+        )
+    (request,) = wire.requests
+    assert framing(request) == ("10", None)
+    assert request.body == b"0123456789"
+
+
+def test_a_length_the_caller_set_cuts_a_longer_body_at_that_length(http_transport):
+    with Wire() as wire:
+        put(
+            http_transport,
+            wire,
+            io.BytesIO(PAYLOAD),
+            headers={"Content-Length": "6"},
+        )
+        put(http_transport, wire, b"next")
+    first, second = wire.requests
+    assert framing(first) == ("6", None)
+    assert first.body == PAYLOAD[:6]
+    # Nothing of the rest was sent: the next request on the connection is whole.
+    assert (second.method, second.target, second.body) == ("PUT", "/up", b"next")
+
+
+def test_a_length_the_caller_set_on_bytes_cuts_them_there(http_transport):
+    with Wire() as wire:
+        put(http_transport, wire, PAYLOAD, headers={"content-length": "4"})
+    (request,) = wire.requests
+    assert framing(request) == ("4", None)
+    assert request.body == PAYLOAD[:4]
+
+
+@pytest.mark.parametrize(
+    "body", [PAYLOAD, io.BytesIO(PAYLOAD), [PAYLOAD]], ids=["bytes", "file", "list"]
+)
+def test_a_length_larger_than_a_body_whose_size_is_known_is_refused(
+    http_transport, body
+):
+    with Wire() as wire:
+        with pytest.raises(ValueError):
+            put(http_transport, wire, body, headers={"Content-Length": "99"})
+        assert wire.connections == 0
+
+
+@pytest.mark.parametrize("value", ["-1", "ten", "1.5", "", "1, 2"])
+def test_a_length_that_is_not_a_count_of_bytes_is_refused(http_transport, value):
+    with Wire() as wire:
+        with pytest.raises(ValueError):
+            put(http_transport, wire, PAYLOAD, headers={"Content-Length": value})
+        assert wire.connections == 0
+
+
+def test_a_generator_that_ends_before_the_length_the_caller_set_is_an_error(
+    http_transport,
+):
+    with Wire() as wire:
+        with pytest.raises(OSError) as excinfo:
+            put(
+                http_transport,
+                wire,
+                (piece for piece in (b"0123", b"4567")),
+                headers={"Content-Length": "10"},
+                timeout=(5, 0.5),
+            )
+    # Not a wait for the rest of the body that never comes.
+    assert not isinstance(excinfo.value, TimeoutError)
+
+
+# --- a length that was right when it was taken ---------------------------------------
+
+
+def test_a_file_that_grew_after_it_was_measured_sends_only_the_length_it_stated(
+    http_transport,
+):
+    with Wire() as wire:
+        put(http_transport, wire, Growing(PAYLOAD))
+        put(http_transport, wire, b"next")
+    first, second = wire.requests
+    assert framing(first) == (str(len(PAYLOAD)), None)
+    assert first.body == PAYLOAD
+    # Nothing past the length was sent: the next request is not preceded by it.
+    assert (second.method, second.target, second.body) == ("PUT", "/up", b"next")
+
+
+def test_a_file_that_ends_before_the_length_it_stated_is_an_error(http_transport):
+    with Wire() as wire:
+        with pytest.raises(OSError) as excinfo:
+            put(http_transport, wire, Shrinking(PAYLOAD), timeout=(5, 0.5))
+    assert not isinstance(excinfo.value, TimeoutError)
+
+
+# --- a body with a length is still sent once -----------------------------------------
+
+
+def test_a_file_with_a_known_length_is_not_sent_again_on_a_dropped_connection():
+    def script(request):
+        if request.connection == 0 and request.body == b"two":
+            return Drop()
+        return response(body=b"ok")
+
+    with Wire(script) as wire:
+        with HTTPTransport() as transport:
+            put(transport, wire, io.BytesIO(b"one"))
+            with pytest.raises(OSError):
+                put(transport, wire, io.BytesIO(b"two"))
+    assert [(r.connection, r.body) for r in wire.requests] == [
+        (0, b"one"),
+        (0, b"two"),
+    ]