pathapi 0.1.0__py3-none-any.whl

pathapi/http/testing/suite/conftest.py

@@ -0,0 +1,98 @@
+"""Fixtures of the HTTP transport suite.
+
+The suite checks one transport per run (`--http-transports`), against servers
+on the loopback interface only, and needs nothing but `pytest`, the standard
+library and `pathapi` (the TLS tests also need `cryptography`, and skip
+without it). It is shipped with `pathapi.http.testing` so that another
+distribution can hold its transport to the same promises.
+"""
+
+import socket
+import tempfile
+
+import pytest
+
+import transport_guard
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--http-transports",
+        default="builtin",
+        help="the HTTP transports the transport suite runs against, by the "
+        "names of pathapi.http.transport_names(), separated by commas "
+        "(for example builtin,requests)",
+    )
+
+
+def pytest_configure(config):
+    # The session's environment is set before the first test's snapshot of it
+    # is taken, and put back when pytest exits.
+    home = tempfile.TemporaryDirectory(prefix="pathapi-transport-home-")
+    patch = pytest.MonkeyPatch()
+    transport_guard.isolate_environment(patch, home.name)
+    config.add_cleanup(home.cleanup)
+    config.add_cleanup(patch.undo)
+
+
+@pytest.fixture(autouse=True)
+def _environment_unchanged():
+    """A test that leaves the process environment changed fails; the
+    environment is put back first so that the next test starts clean."""
+    before = transport_guard.environment_snapshot()
+    yield
+    changed = transport_guard.changed_variables(
+        before, transport_guard.environment_snapshot()
+    )
+    if changed:
+        transport_guard.restore_environment(before)
+        pytest.fail(
+            "the test left the process environment changed (use monkeypatch): "
+            + ", ".join(f"{k}: {old!r} -> {new!r}" for k, (old, new) in changed.items())
+        )
+
+
+@pytest.fixture(autouse=True)
+def _block_non_loopback_network(_environment_unchanged, monkeypatch):
+    """Any connect, send or name lookup aimed at a host other than loopback
+    raises `NetworkAccessBlocked`, and a blocked attempt fails the test at
+    teardown even if the code under test swallowed the error."""
+    blocked = []
+    transport_guard.install_network_guard(monkeypatch, blocked)
+    yield blocked
+    if blocked:
+        pytest.fail(f"non-loopback network access attempted: {blocked}")
+
+
+def pytest_generate_tests(metafunc):
+    if "http_transport_kind" in metafunc.fixturenames:
+        option = metafunc.config.getoption("--http-transports", default="builtin")
+        kinds = [name.strip() for name in option.split(",") if name.strip()]
+        metafunc.parametrize("http_transport_kind", kinds, indirect=True)
+
+
+@pytest.fixture
+def http_transport_kind(request, monkeypatch):
+    """Runs the test once per HTTP transport (`--http-transports`): the
+    default transport of every client the test builds is that kind
+    (`PATHAPI_HTTP_TRANSPORT`), and `transport_fakes.make_transport(kind)`
+    builds one of it."""
+    monkeypatch.setenv("PATHAPI_HTTP_TRANSPORT", request.param)
+    return request.param
+
+
+@pytest.fixture
+def http_transport(http_transport_kind):
+    """A transport of the kind under test, closed after the test."""
+    from transport_fakes import make_transport
+
+    with make_transport(http_transport_kind) as transport:
+        yield transport
+
+
+@pytest.fixture
+def unused_tcp_port():
+    """A port nobody is listening on, for connection-refused coverage."""
+    with socket.socket() as probe:
+        probe.bind(("127.0.0.1", 0))
+        return probe.getsockname()[1]

pathapi/http/testing/suite/test_client_default.py

@@ -0,0 +1,285 @@
+"""The client: which transport it sends with when it is not given one (the
+built-in one, the `requests` one only when asked, and nothing imported that is
+not needed), what it closes, and the headers and timeout every request gets."""
+
+import base64
+import os
+import pathlib
+import subprocess
+import sys
+import textwrap
+
+import pytest
+
+import pathapi
+import pathapi.http as http
+from pathapi.http import HTTPClient, HTTPTransport
+from transport_fakes import FakeTransport, reply
+from transport_wire import Hang, Wire
+
+_SRC = pathlib.Path(pathapi.__file__).resolve().parent.parent
+VARIABLE = "PATHAPI_HTTP_TRANSPORT"
+
+
+def test_the_variable_in_the_module_is_the_one_the_code_reads():
+    assert http.TRANSPORT_ENV == VARIABLE
+
+
+def test_without_a_setting_the_built_in_transport_is_used(monkeypatch):
+    monkeypatch.delenv(VARIABLE, raising=False)
+    with HTTPClient() as client:
+        assert type(client.transport) is HTTPTransport
+
+
+def test_a_client_builds_its_transport_on_first_use_and_keeps_it(monkeypatch):
+    monkeypatch.delenv(VARIABLE, raising=False)
+    with HTTPClient() as client:
+        assert client._transport is None
+        first = client.transport
+        assert client.transport is first
+
+
+def test_the_variable_chooses_the_transport(monkeypatch):
+    monkeypatch.setenv(VARIABLE, "builtin")
+    with HTTPClient() as client:
+        assert type(client.transport) is HTTPTransport
+
+
+def test_the_uripath_variable_does_not_choose_the_transport(monkeypatch):
+    monkeypatch.delenv(VARIABLE, raising=False)
+    monkeypatch.setenv("URIPATH_HTTP_TRANSPORT", "requests")
+    with HTTPClient() as client:
+        assert type(client.transport) is HTTPTransport
+
+
+@pytest.mark.parametrize("value", ["", "Requests", "BUILTIN", "urllib3", " builtin"])
+def test_a_value_that_is_not_a_choice_is_a_value_error_naming_the_choices(
+    monkeypatch, value
+):
+    monkeypatch.setenv(VARIABLE, value)
+    client = HTTPClient()
+    with pytest.raises(ValueError) as excinfo:
+        client.transport
+    message = str(excinfo.value)
+    assert VARIABLE in message and "'builtin'" in message and "'requests'" in message
+
+
+def test_a_bad_setting_is_reported_when_the_client_sends_not_when_it_is_built(
+    monkeypatch,
+):
+    monkeypatch.setenv(VARIABLE, "nonsense")
+    client = HTTPClient()
+    with pytest.raises(ValueError):
+        client.request("GET", "http://127.0.0.1:1/x")
+
+
+def test_a_client_closes_the_transport_it_built_and_not_one_it_was_given(monkeypatch):
+    monkeypatch.delenv(VARIABLE, raising=False)
+    given = FakeTransport(default=reply(200))
+    client = HTTPClient(given)
+    client.close()
+    assert given.closed == 0
+
+    built = HTTPClient()
+    transport = built.transport
+    closed = []
+    transport.close = lambda: closed.append(True)
+    built.close()
+    built.close()
+    assert closed == [True]
+
+
+def test_a_transport_is_an_object_with_a_send_method():
+    with pytest.raises(TypeError):
+        HTTPClient(object())
+
+
+def test_the_representation_of_a_client_shows_no_header():
+    client = HTTPClient(headers={"Authorization": "Bearer SECRET"})
+    assert "SECRET" not in repr(client) and "Authorization" not in repr(client)
+
+
+# --- what every request carries -------------------------------------------------
+
+
+def test_a_request_names_the_library_and_its_version_as_its_user_agent():
+    transport = FakeTransport(default=reply(200))
+    HTTPClient(transport).request("GET", "http://h/x")
+    sent = transport.sent[0].headers
+    assert sent["User-Agent"] == f"pathapi/{pathapi.__version__}"
+    assert sent["Accept"] == "*/*"
+
+
+def test_the_user_agent_can_be_named_by_the_caller_of_the_client():
+    transport = FakeTransport(default=reply(200))
+    client = HTTPClient(transport, user_agent="tool/1.2")
+    assert client.user_agent == "tool/1.2"
+    client.request("GET", "http://h/x")
+    assert transport.sent[0].headers["User-Agent"] == "tool/1.2"
+
+
+def test_headers_are_merged_by_name_the_call_over_the_client_over_the_base():
+    transport = FakeTransport(default=reply(200))
+    client = HTTPClient(transport, headers={"accept": "text/html", "X-A": "client"})
+    client.request("GET", "http://h/x", headers={"x-a": "call", "X-B": "call"})
+    sent = transport.sent[0].headers
+    assert {k.lower(): v for k, v in sent.items()} == {
+        "user-agent": f"pathapi/{pathapi.__version__}",
+        "accept": "text/html",
+        "x-a": "call",
+        "x-b": "call",
+    }
+    assert len(sent) == 4
+
+
+def test_a_header_set_to_none_in_the_call_is_not_sent():
+    transport = FakeTransport(default=reply(200))
+    HTTPClient(transport).request("GET", "http://h/x", headers={"Accept": None})
+    assert "Accept" not in transport.sent[0].headers
+
+
+def test_credentials_given_as_auth_are_sent_as_a_basic_authorization():
+    transport = FakeTransport(default=reply(200))
+    HTTPClient(transport).request("GET", "http://h/x", auth=("al@ice", "s3cr3t"))
+    expected = "Basic " + base64.b64encode(b"al@ice:s3cr3t").decode("ascii")
+    assert transport.sent[0].headers["Authorization"] == expected
+    assert transport.sent[0].url == "http://h/x"
+
+
+def test_a_string_given_as_auth_is_the_authorization_value():
+    transport = FakeTransport(default=reply(200))
+    HTTPClient(transport).request("GET", "http://h/x", auth="Bearer TOKEN")
+    assert transport.sent[0].headers["Authorization"] == "Bearer TOKEN"
+
+
+@pytest.mark.parametrize("where", ["client", "call"])
+def test_an_authorization_header_wins_over_auth(where):
+    transport = FakeTransport(default=reply(200))
+    options = {"headers": {"authorization": "Bearer B"}}
+    client = HTTPClient(transport, **(options if where == "client" else {}))
+    client.request(
+        "GET",
+        "http://h/x",
+        auth=("alice", "pw"),
+        **(options if where == "call" else {}),
+    )
+    sent = transport.sent[0].headers
+    assert [v for k, v in sent.items() if k.lower() == "authorization"] == ["Bearer B"]
+
+
+def test_a_url_with_credentials_is_refused_before_anything_is_sent():
+    transport = FakeTransport(default=reply(200))
+    with pytest.raises(ValueError) as excinfo:
+        HTTPClient(transport).request("GET", "http://alice:s3cr3t@h/x")
+    assert "s3cr3t" not in str(excinfo.value)
+    assert transport.sent == []
+
+
+def test_a_header_or_url_with_a_line_break_is_refused_before_any_transport_call():
+    transport = FakeTransport(default=reply(200))
+    for headers in ({"X-A": "1\r\nX-B: 2"}, {"X-A": "1\n2"}):
+        with pytest.raises(ValueError):
+            HTTPClient(transport, headers=headers).request("GET", "http://h/x")
+        with pytest.raises(ValueError):
+            HTTPClient(transport).request("GET", "http://h/x", headers=headers)
+    with pytest.raises(ValueError):
+        HTTPClient(transport).request("GET", "http://h/x\r\nX-A: 1")
+    assert transport.sent == []
+
+
+def test_a_text_body_is_sent_as_utf_8():
+    transport = FakeTransport(default=reply(200))
+    HTTPClient(transport).request("PUT", "http://h/x", data="café")
+    assert transport.sent[0].body == "café".encode("utf-8")
+
+
+def test_a_reply_is_asked_for_streamed_whatever_the_caller_asked():
+    transport = FakeTransport(default=reply(200, b"abc"))
+    client = HTTPClient(transport)
+    assert client.request("GET", "http://h/x").read() == b"abc"
+    client.request("GET", "http://h/x", stream=True).close()
+    assert [call.stream for call in transport.sent] == [True, True]
+
+
+# --- the timeout -----------------------------------------------------------------
+
+
+def test_a_request_without_a_timeout_gets_the_default():
+    transport = FakeTransport()
+    HTTPClient(transport).request("GET", "http://h/x")
+    assert transport.sent[-1].timeout == (10, 60) == http.DEFAULT_TIMEOUT
+
+
+@pytest.mark.parametrize("timeout", [5, None])
+def test_a_timeout_of_the_client_or_the_call_wins(timeout):
+    transport = FakeTransport()
+    HTTPClient(transport, timeout=timeout).request("GET", "http://h/x")
+    assert transport.sent[-1].timeout == timeout
+    HTTPClient(transport).request("GET", "http://h/x", timeout=timeout)
+    assert transport.sent[-1].timeout == timeout
+
+
+def test_a_stalled_server_times_out_when_the_client_has_a_timeout(http_transport_kind):
+    with Wire(lambda r: Hang()) as wire:
+        with HTTPClient(timeout=(2, 0.5)) as client:
+            with pytest.raises(TimeoutError):
+                client.request("GET", wire.url + "/x")
+
+
+# --- no third-party library ---------------------------------------------------
+
+_CHILD = """
+import sys
+
+import pathapi
+
+assert not {"ssl", "http.client"} & set(sys.modules)
+sys.modules["requests"] = None
+sys.modules["urllib3"] = None
+
+import http.server, threading
+
+
+class Handler(http.server.BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+
+    def log_message(self, *args):
+        pass
+
+    def do_GET(self):
+        body = b"hello"
+        self.send_response(200)
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+
+server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+threading.Thread(target=server.serve_forever, daemon=True).start()
+
+from pathapi.http import HTTPClient
+
+with HTTPClient() as client:
+    reply = client.request("GET", "http://127.0.0.1:%d/f" % server.server_port)
+    print(reply.status, reply.read())
+print(sorted(m for m in ("requests", "urllib3") if sys.modules.get(m) is not None))
+server.shutdown()
+server.server_close()
+"""
+
+
+def test_a_request_works_with_requests_and_urllib3_hidden_and_the_root_loads_no_ssl():
+    env = dict(os.environ)
+    env["PYTHONPATH"] = os.pathsep.join(
+        filter(None, [str(_SRC), env.get("PYTHONPATH")])
+    )
+    env.pop(VARIABLE, None)
+    result = subprocess.run(
+        [sys.executable, "-c", textwrap.dedent(_CHILD)],
+        capture_output=True,
+        text=True,
+        timeout=120,
+        env=env,
+    )
+    assert result.returncode == 0, result.stderr
+    assert result.stdout.splitlines() == ["200 b'hello'", "[]"]

pathapi/http/testing/suite/test_client_errors.py

@@ -0,0 +1,181 @@
+"""How a failed request becomes the `OSError` a path raises: the status of a
+reply maps to the `pathlib` exception type for its meaning, and the error of a
+transport is raised again without its cause, so that a URL, a header or a
+credential it quotes is in no message or traceback."""
+
+import errno
+import traceback
+
+import pytest
+
+from pathapi.http import (
+    HTTPClient,
+    HTTPStatusError,
+    os_error,
+    raise_for_status,
+    server_size,
+    translate_errors,
+)
+from transport_fakes import FakeTransport, reply
+from transport_wire import Wire, refusing_port, response
+
+SUBJECT = "http://host.test/f"
+
+
+def formatted(error: BaseException) -> str:
+    """Everything a log line or traceback could show for `error`."""
+    return "".join(
+        traceback.format_exception(type(error), error, error.__traceback__)
+    ) + "\n".join((str(error), repr(error)))
+
+
+def failing_with(status, reason="", **options):
+    client = HTTPClient(FakeTransport({("GET", SUBJECT): reply(status, reason=reason)}))
+    with translate_errors(SUBJECT, **options):
+        raise_for_status(client.request("GET", SUBJECT))
+
+
+@pytest.mark.parametrize(
+    "status, error, number",
+    [
+        (404, FileNotFoundError, errno.ENOENT),
+        (410, FileNotFoundError, errno.ENOENT),
+        (401, PermissionError, errno.EACCES),
+        (403, PermissionError, errno.EACCES),
+        (409, FileExistsError, errno.EEXIST),
+    ],
+)
+def test_a_status_becomes_the_exception_pathlib_raises_for_its_meaning(
+    status, error, number
+):
+    with pytest.raises(error) as excinfo:
+        failing_with(status)
+    assert type(excinfo.value) is error
+    assert excinfo.value.errno == number
+    assert excinfo.value.filename == SUBJECT
+
+
+def test_a_conflict_means_a_missing_parent_for_a_write():
+    with pytest.raises(FileNotFoundError):
+        failing_with(409, conflict=FileNotFoundError)
+
+
+@pytest.mark.parametrize("status", [405, 501])
+def test_a_method_the_server_does_not_allow_is_a_permission_error_naming_the_status(
+    status,
+):
+    with pytest.raises(PermissionError) as excinfo:
+        failing_with(status)
+    assert f"HTTP {status}" in str(excinfo.value)
+
+
+@pytest.mark.parametrize("status", [400, 500, 502, 503, 429])
+def test_any_other_status_is_oserror_eio_naming_it_and_the_subject(status):
+    with pytest.raises(OSError) as excinfo:
+        failing_with(status, "Reason")
+    assert type(excinfo.value) is OSError
+    assert excinfo.value.errno == errno.EIO
+    assert f"HTTP Error {status} Reason for {SUBJECT}" in str(excinfo.value)
+
+
+def test_a_status_error_keeps_the_reply_it_was_raised_for():
+    answer = reply(404)
+    with pytest.raises(HTTPStatusError) as excinfo:
+        raise_for_status(answer)
+    assert excinfo.value.response is answer
+    raise_for_status(reply(399))
+
+
+def test_an_error_is_raised_without_its_cause():
+    with pytest.raises(FileNotFoundError) as excinfo:
+        failing_with(404)
+    assert excinfo.value.__cause__ is None
+    assert excinfo.value.__suppress_context__
+
+
+@pytest.mark.parametrize(
+    "make, expected",
+    [
+        (ConnectionError, ConnectionError),
+        (ConnectionRefusedError, ConnectionError),
+        (TimeoutError, TimeoutError),
+    ],
+)
+def test_the_error_of_a_transport_never_reaches_the_raised_error(make, expected):
+    # A transport's error can quote a proxy URL taken from the environment,
+    # credentials included; none of it may be in the error or its traceback.
+    quoted = "http://proxyuser:pr0xyS3cret@proxy.example:3128"
+    transport = FakeTransport()
+    transport.fail = make(f"ProxyError({quoted})")
+    with pytest.raises(expected) as excinfo:
+        with translate_errors(SUBJECT):
+            HTTPClient(transport).request("GET", SUBJECT)
+    assert "pr0xyS3cret" not in formatted(excinfo.value)
+    assert SUBJECT in str(excinfo.value)
+    assert type(make("")).__name__ in str(excinfo.value)
+    assert excinfo.value.__cause__ is None
+    assert excinfo.value.__suppress_context__
+
+
+def test_a_refused_connection_carries_no_cause(http_transport_kind):
+    with HTTPClient() as client:
+        with pytest.raises(ConnectionError) as excinfo:
+            with translate_errors(SUBJECT):
+                client.request("GET", f"http://127.0.0.1:{refusing_port()}/x")
+    assert excinfo.value.__cause__ is None
+    assert excinfo.value.__suppress_context__
+
+
+def test_a_stalled_server_is_a_timeout_error_without_a_cause(http_transport_kind):
+    from transport_wire import Hang
+
+    with Wire(lambda r: Hang()) as wire:
+        with HTTPClient(timeout=0.5) as client:
+            with pytest.raises(TimeoutError) as excinfo:
+                with translate_errors(SUBJECT):
+                    client.request("GET", wire.url + "/x")
+    assert SUBJECT in str(excinfo.value)
+    assert excinfo.value.__cause__ is None
+    assert excinfo.value.__suppress_context__
+
+
+def test_an_error_that_is_not_a_request_failure_passes_through():
+    with pytest.raises(KeyError):
+        with translate_errors(SUBJECT):
+            raise KeyError("x")
+
+
+def test_os_error_is_built_as_pathlib_builds_it():
+    error = os_error(IsADirectoryError, SUBJECT)
+    assert (type(error), error.errno, error.filename) == (
+        IsADirectoryError,
+        errno.EISDIR,
+        SUBJECT,
+    )
+    other = os_error(OSError, SUBJECT)
+    assert (other.errno, other.filename) == (errno.EIO, SUBJECT)
+
+
+@pytest.mark.parametrize(
+    "text, size",
+    [("5", 5), (" 12 ", 12), ("0", 0), (None, None), ("", None)]
+    + [("-1", None), ("1e3", None), ("1.5", None), ("٣", None)]
+    + [("9" * 20, None), ("0x10", None)],
+)
+def test_a_size_a_server_states_is_a_plain_count_or_nothing(text, size):
+    assert server_size(text) == size
+
+
+def test_a_reply_status_error_text_has_the_reason_escaped():
+    esc = "\x1b[31m"
+    with Wire(
+        lambda r: (
+            f"HTTP/1.1 500 Server {esc}Error\r\nContent-Length: 0\r\n\r\n"
+        ).encode("latin-1")
+    ) as wire:
+        with HTTPClient() as client:
+            with pytest.raises(OSError) as excinfo:
+                with translate_errors(SUBJECT):
+                    raise_for_status(client.request("GET", wire.url + "/x"))
+    assert "\x1b" not in str(excinfo.value)
+    assert "Server \\x1b[31mError" in str(excinfo.value)

pathapi/http/testing/suite/test_client_peer_text.py

@@ -0,0 +1,86 @@
+"""Text from the other end that goes into an exception message: a reason
+phrase, a `Location`. It is shown with its control characters escaped and cut
+to a length, whichever transport sent the request."""
+
+import pytest
+
+from pathapi.http import HTTPClient, peer_text, raise_for_status, translate_errors
+from transport_wire import Reply, Wire
+
+pytestmark = pytest.mark.usefixtures("http_transport_kind")
+
+ESC = "\x1b[31m"
+
+
+def reply_with_reason(reason, status=500):
+    raw = f"HTTP/1.1 {status} {reason}\r\nContent-Length: 0\r\n\r\n".encode("latin-1")
+    return lambda request: Reply(raw)
+
+
+# --- the helper --------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "text, shown",
+    [
+        ("plain", "plain"),
+        ("café 日本", "café 日本"),
+        ("a\x1b[31mb", "a\\x1b[31mb"),
+        ("a\r\nb\tc\x00d", "a\\r\\nb\\tc\\x00d"),
+        ("a‮b", "a\\u202eb"),  # a right-to-left override
+        ("a
b", "a\\u2028b"),  # a line separator
+        ("a\x9bb", "a\\x9bb"),  # the C1 control that starts an escape sequence
+    ],
+)
+def test_peer_text_escapes_what_a_terminal_would_act_on(text, shown):
+    assert peer_text(text) == shown
+
+
+def test_peer_text_is_cut_to_its_limit():
+    assert peer_text("x" * 500) == "x" * 120 + "..."
+    assert peer_text("x" * 20, limit=20) == "x" * 20
+    assert peer_text("\x1b" * 500, limit=10) == "\\x1b" * 10 + "..."
+
+
+# --- where the library shows it --------------------------------------------------
+
+
+def test_a_reason_phrase_is_shown_escaped():
+    with Wire(reply_with_reason(f"Server {ESC}Error")) as wire:
+        with HTTPClient() as client:
+            with pytest.raises(OSError) as excinfo:
+                with translate_errors(wire.url):
+                    raise_for_status(client.request("GET", wire.url + "/x"))
+    message = str(excinfo.value)
+    assert "\x1b" not in message
+    assert "Server \\x1b[31mError" in message
+
+
+def test_a_long_reason_phrase_is_cut():
+    with Wire(reply_with_reason("R" * 20000)) as wire:
+        with HTTPClient() as client:
+            with pytest.raises(OSError) as excinfo:
+                with translate_errors(wire.url):
+                    raise_for_status(client.request("GET", wire.url + "/x"))
+    assert len(str(excinfo.value)) < 400
+
+
+def test_a_redirect_that_is_refused_is_shown_cut_and_with_an_escaped_reason(
+    http_transport,
+):
+    location = "/" + "a" * 5000
+
+    def script(request):
+        raw = (
+            f"HTTP/1.1 302 Found {ESC}\r\nLocation: {location}\r\n"
+            "Content-Length: 0\r\n\r\n"
+        ).encode("latin-1")
+        return Reply(raw)
+
+    with Wire(script) as wire:
+        client = HTTPClient(http_transport)
+        with pytest.raises(OSError) as excinfo:
+            client.request("PUT", wire.url + "/f", data=b"x")
+    message = str(excinfo.value)
+    assert "\x1b" not in message and "\\x1b[31m" in message
+    assert len(message) < 500