py2http 0.1.69__tar.gz → 0.1.71__tar.gz

{py2http-0.1.69 → py2http-0.1.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py2http
-Version: 0.1.69
+Version: 0.1.71
 Summary: Declarative HTTP service entry point.
 Home-page: https://github.com/i2mint/py2http
 License: MIT

{py2http-0.1.69 → py2http-0.1.71}/py2http/bottle_plugins.py

@@ -17,7 +17,7 @@ from py2http.auth import (
     key_matches,
     required_key,
 )
-from py2http.constants import JSON_CONTENT_TYPE
+from py2http.constants import API_KEY_CHALLENGE, BEARER_CHALLENGE, JSON_CONTENT_TYPE
 
 OPTIONS = "OPTIONS"
 
@@ -31,8 +31,9 @@ def _authorization_header() -> str:
         return ""
 
 
-def _unauthorized(message):
+def _unauthorized(message, challenge=BEARER_CHALLENGE):
     response.status = 401
+    response.set_header("WWW-Authenticate", challenge)
     response.content_type = JSON_CONTENT_TYPE
     return json.dumps({"error": message})
 
@@ -126,7 +127,7 @@ class ApiKeyAuthPlugin:
         def wrapped_handler(*args, **kwargs):
             if key_matches(_authorization_header(), self._api_key):
                 return handler(*args, **kwargs)
-            return _unauthorized("invalid API key")
+            return _unauthorized("invalid API key", API_KEY_CHALLENGE)
 
         return wrapped_handler
 

{py2http-0.1.69 → py2http-0.1.71}/py2http/constants.py

@@ -5,3 +5,11 @@ BINARY_CONTENT_TYPE = "application/octet-stream"
 FORM_CONTENT_TYPE = "multipart/form-data"
 RAW_CONTENT_TYPE = "text/plain"
 HTML_CONTENT_TYPE = "text/html"
+
+# ``WWW-Authenticate`` challenges sent with every 401 (RFC 7235 requires one): a JWT is
+# sent as ``Authorization: Bearer <token>``; an API key as the bare header value.
+BEARER_CHALLENGE = "Bearer"
+API_KEY_CHALLENGE = "ApiKey"
+#: Environment variable naming the challenge for a 401 a dispatched function raised
+#: (``AuthorizationError``); the deployment's auth decides it. Default: Bearer.
+WWW_AUTHENTICATE_ENV_VAR = "PY2HTTP_WWW_AUTHENTICATE"

{py2http-0.1.69 → py2http-0.1.71}/py2http/default_configs.py

@@ -15,6 +15,7 @@ up an HTTP service in Python using the py2http library."""
 from aiohttp import web
 from bottle import response
 import json
+import logging
 import os
 
 from i2.errors import (
@@ -28,7 +29,13 @@ from i2.errors import (
 
 from py2http.decorators import handle_json_req, send_json_resp, JsonRespEncoder
 from py2http.config import AIOHTTP, BOTTLE, FLASK
-from py2http.constants import JSON_CONTENT_TYPE
+from py2http.constants import (
+    BEARER_CHALLENGE,
+    JSON_CONTENT_TYPE,
+    WWW_AUTHENTICATE_ENV_VAR,
+)
+
+logger = logging.getLogger(__name__)
 
 DFLT_CONTENT_TYPE = JSON_CONTENT_TYPE
 
@@ -52,14 +59,41 @@ def bottle_output_mapper(output, **inputs):
     return json.dumps(output, cls=JsonRespEncoder)
 
 
-def _raise_http_client_error(error, message, reason=None):
+def _raise_http_client_error(error, message, reason=None, headers=None):
     raise error(
         text=json.dumps({"error": message}),
         content_type=JSON_CONTENT_TYPE,
         reason=reason,
+        headers=headers,
     )
 
 
+def www_authenticate_challenge() -> str:
+    """The ``WWW-Authenticate`` value of a 401 a dispatched function raised: the
+    ``PY2HTTP_WWW_AUTHENTICATE`` environment variable, else ``Bearer`` (also when the
+    variable holds a line break, which would make every 401 fail to send).
+
+    >>> os.environ.pop(WWW_AUTHENTICATE_ENV_VAR, None) and None
+    >>> www_authenticate_challenge()
+    'Bearer'
+    """
+    challenge = os.getenv(WWW_AUTHENTICATE_ENV_VAR)
+    if not challenge:
+        return BEARER_CHALLENGE
+    if any(c in challenge for c in "\r\n\0"):
+        logger.warning(
+            "%s holds a control character; sending %r instead",
+            WWW_AUTHENTICATE_ENV_VAR,
+            BEARER_CHALLENGE,
+        )
+        return BEARER_CHALLENGE
+    return challenge
+
+
+def _status_headers(status: int) -> dict:
+    return {"WWW-Authenticate": www_authenticate_challenge()} if status == 401 else {}
+
+
 # HTTP status of each client error, most specific class first. ``ForbiddenError`` and
 # ``OverwritesNotAllowed`` mean the client may not do this (403); any other
 # ``AuthorizationError`` means the request did not say who it is (401).
@@ -96,20 +130,34 @@ def aiohttp_error_handler(error: Exception):
     if status == 500:
         _raise_http_client_error(web.HTTPInternalServerError, "Internal server error")
     reason = type(error).__name__ if status == 400 else None
-    _raise_http_client_error(_AIOHTTP_ERRORS[status], str(error), reason=reason)
+    _raise_http_client_error(
+        _AIOHTTP_ERRORS[status],
+        str(error),
+        reason=reason,
+        headers=_status_headers(status) or None,
+    )
 
 
 def bottle_error_handler(error: Exception):
     message = str(error)
     status = error_status(error)
     response.status = f"400 {type(error).__name__}" if status == 400 else status
+    for header, value in _status_headers(status).items():
+        response.set_header(header, value)
     if status == 500 and os.getenv("OPAQUE_ERRORS", None):
         message = "Internal server error"
     return {"error": message}
 
 
 def flask_error_handler(error: Exception):
-    raise NotImplementedError()
+    """The ``(body, status, headers)`` a Flask view returns for an error, mapped like
+    the bottle handler (``OPAQUE_ERRORS`` hides the text of a 500)."""
+    message = str(error)
+    status = error_status(error)
+    if status == 500 and os.getenv("OPAQUE_ERRORS", None):
+        message = "Internal server error"
+    status_line = f"400 {type(error).__name__}" if status == 400 else status
+    return {"error": message}, status_line, _status_headers(status)
 
 
 def default_error_handler(error: Exception):

{py2http-0.1.69 → py2http-0.1.71}/py2http/middleware.py

@@ -19,16 +19,18 @@ from py2http.auth import (
     key_matches,
     required_key,
 )
-from py2http.constants import JSON_CONTENT_TYPE
+from py2http.constants import API_KEY_CHALLENGE, BEARER_CHALLENGE, JSON_CONTENT_TYPE
 
 DFLT_PUBLIC_ROUTES = ("ping", "openapi")
 
 
-def _unauthorized(message):
+def _unauthorized(message, challenge=BEARER_CHALLENGE):
     from aiohttp import web
 
     return web.HTTPUnauthorized(
-        text=json.dumps({"error": message}), content_type=JSON_CONTENT_TYPE
+        text=json.dumps({"error": message}),
+        content_type=JSON_CONTENT_TYPE,
+        headers={"WWW-Authenticate": challenge},
     )
 
 
@@ -119,6 +121,6 @@ def mk_superadmin_middleware(secret):
     async def middleware(req, handler):
         if key_matches(req.headers.get("Authorization"), secret):
             return await handler(req)
-        raise _unauthorized("invalid API key")
+        raise _unauthorized("invalid API key", API_KEY_CHALLENGE)
 
     return middleware

{py2http-0.1.69 → py2http-0.1.71}/py2http/obj_dispatch.py

@@ -3,13 +3,20 @@
 A handler whose ``endpoint`` is not a function names the attributes clients may call
 with ``attr_names`` (see ``public_attr`` for ``'*'``):
 
-- a **module**: its functions are called by name;
+- a **module**: its functions are called by name. They are function endpoints like
+  any other: no object is kept, so there is no size bound, and a function that mutates
+  module globals does so for every client, exactly as a plain function endpoint (or a
+  bound method passed into an app spec) would. Authenticate with the auth middleware
+  (``mk_jwt_middleware``, ``JWTPlugin``), or pass an optional ``obj_owner`` to refuse
+  requests it does not identify;
 - an **instance** (one object every client shares): ``_instance_endpoint_dispatcher``;
 - a **class** (each client creates and uses its own objects):
   ``_class_endpoint_dispatcher``.
 
 Instances and classes need an ``obj_owner``, a ``(request) -> owner`` hook reading
-``current_request``, and are bounded in size (``py2http.sizeof``).
+``current_request``, and are bounded in size (``py2http.sizeof``), measured after each
+call except those to ``obj_readers``. A call returning a generator, coroutine or async
+generator is measured when it is returned and again when that result finishes.
 """
 
 import inspect
@@ -323,8 +330,14 @@ def _get_func_to_dispatch_handler(handler):
         func = _class_endpoint_dispatcher(endpoint, handler, name, is_dispatchable)
 
     elif isinstance(endpoint, ModuleType):  # a module's functions: no shared object
+        owner_of = handler.get("obj_owner")
+        if owner_of is None or owner_of is shared_objects:
+            owner = lambda: None  # noqa: E731
+        else:
+            owner = _request_owner(owner_of, name)
 
         def func(_attr_name=None, **kwargs):
+            owner()  # an optional gate: refuses requests the hook does not identify
             return _get_attr_value(endpoint, _attr_name, is_dispatchable, **kwargs)
 
     else:
@@ -410,9 +423,14 @@ def _instance_endpoint_dispatcher(obj, handler, name, is_dispatchable):
       for a large object. Not measured: data the object keeps outside the process
       (files, a database), and state held in its class or in module globals.
       Measuring walks the object (up to ``max_obj_size`` bytes of it) after every
-      call, reads included, so a large limit costs time on every request. A method
-      returning a generator or coroutine does its work after the measure: what it
-      adds is caught by the next call.
+      call except those to ``obj_readers``, so a large limit costs time on each such
+      request. A method returning a generator, coroutine or async generator is
+      measured when it returns and again when that result finishes.
+    - ``obj_readers``: names of dispatched attributes that never add to the object
+      (``read``, ``keys``, ``get``...; not ``__getitem__`` of a ``defaultdict``, which
+      inserts): calls to them are not measured, which saves the walk on every read. Empty by default; the bound holds only if every
+      name listed really never adds (what one does add is caught by the next measured
+      call).
     - ``obj_shrinkers``: names of dispatched attributes that only ever remove
       (``pop``, ``clear``, ``__delitem__`` if ``attr_names`` lists it...), still
       callable while the object is over its limit so a client can bring it back under.
@@ -443,16 +461,8 @@ def _instance_endpoint_dispatcher(obj, handler, name, is_dispatchable):
             f"{max_obj_size} bytes (as measured by obj_sizeof): raise max_obj_size, pass "
             "an obj_sizeof that skips what clients cannot grow, or max_obj_size=None."
         )
-    shrinkers = handler.get("obj_shrinkers", ())
-    if isinstance(shrinkers, str):
-        raise TypeError(f"obj_shrinkers must be a collection of names: {shrinkers!r}")
-    shrinkers = frozenset(shrinkers)
-    for attr_name in shrinkers:
-        if not is_dispatchable(obj, attr_name):
-            raise ValueError(
-                f"obj_shrinkers of {name!r}: {attr_name!r} is not dispatched "
-                "(see attr_names)"
-            )
+    shrinkers = _names_option(handler, "obj_shrinkers", obj, name, is_dispatchable)
+    readers = _names_option(handler, "obj_readers", obj, name, is_dispatchable)
     over_limit = threading.Event()  # set while the object is known to be too big
     measuring = threading.Lock()  # so a stale measure cannot clear a newer one's flag
 
@@ -478,13 +488,20 @@ def _instance_endpoint_dispatcher(obj, handler, name, is_dispatchable):
         shrinking = isinstance(_attr_name, str) and _attr_name in shrinkers
         if over_limit.is_set() and measure() and not shrinking:
             refuse()
-        try:
+
+        def call():
             return _get_attr_value(obj, _attr_name, is_dispatchable, **kwargs)
-        finally:  # a call that grows the object and then raises is measured too
+
+        if isinstance(_attr_name, str) and _attr_name in readers:
+            return call()
+
+        def settle():
             # a shrinker that ran but left it over the limit keeps its result
             if measure() and not shrinking:
                 refuse()
 
+        return _call_then_settle(call, settle)
+
     return func
 
 
@@ -512,7 +529,10 @@ def _class_endpoint_dispatcher(cls, handler, name, is_dispatchable):
       that takes a budget over it is dropped. ``None`` disables a budget. An object
       referencing large shared data (a loaded model) counts that data: raise
       ``max_obj_size`` or pass an ``obj_sizeof`` that skips it. A single call can still
-      allocate before it is measured.
+      allocate before it is measured. A method returning a generator, coroutine or
+      async generator is measured when it returns and again when that result finishes.
+    - ``obj_readers``: names of methods that never add to an object; calls to them are
+      not measured (see ``_instance_endpoint_dispatcher``).
     """
     owner_of = handler.get("obj_owner")
     if owner_of is None:
@@ -523,6 +543,10 @@ def _class_endpoint_dispatcher(cls, handler, name, is_dispatchable):
             "client holding an object id use the object, as before."
         )
     max_obj_size = handler.get("max_obj_size", DFLT_MAX_OBJ_SIZE)
+    # the class's own attributes (no object yet for is_dispatchable): catches typos
+    readers = _names_option(
+        handler, "obj_readers", cls, name, lambda c, n: hasattr(c, n)
+    )
     max_owner_bytes = handler.get("max_owner_bytes", DFLT_MAX_OWNER_BYTES)
     max_total_bytes = handler.get("max_total_bytes", DFLT_MAX_TOTAL_BYTES)
     sizeof = handler.get("obj_sizeof", bounded_deep_sizeof)
@@ -584,14 +608,98 @@ def _class_endpoint_dispatcher(cls, handler, name, is_dispatchable):
             raise InputError(f"No object found with id {_obj_id}")
         if _attr_name is None:
             raise InputError("_attr_name must be provided when _obj_id is not None")
-        try:
+
+        def call():
             return _get_attr_value(obj, _attr_name, is_dispatchable, **kwargs)
-        finally:  # a call that grows the object and then raises is measured too
-            check_size(who, _obj_id, obj)
+
+        if isinstance(_attr_name, str) and _attr_name in readers:
+            return call()
+        return _call_then_settle(call, lambda: check_size(who, _obj_id, obj))
 
     return func
 
 
+def _names_option(handler, option, obj, name, is_dispatchable) -> frozenset:
+    """A handler option naming dispatched attributes, validated."""
+    names = handler.get(option, ())
+    if isinstance(names, str):
+        raise TypeError(f"{option} must be a collection of names: {names!r}")
+    names = frozenset(names)
+    for attr_name in names:
+        if not is_dispatchable(obj, attr_name):
+            raise ValueError(
+                f"{option} of {name!r}: {attr_name!r} is not dispatched (see attr_names)"
+            )
+    return names
+
+
+def _settled(result, settle: Callable[[], None]):
+    """``result``, after ``settle()``; for a generator, coroutine or async generator
+    (which do more work after being returned) ``settle()`` runs again when it finishes.
+
+    Settling at return is what bounds a call whose lazy result is never consumed (a
+    generator a JSON encoder refuses, a client that disconnects): whatever the method
+    did before returning is measured either way.
+    """
+    settle()
+    if inspect.isgenerator(result):
+
+        def settling_generator():
+            try:
+                return (yield from result)
+            finally:
+                settle()
+
+        return settling_generator()
+    if inspect.iscoroutine(result):
+
+        async def settling_coroutine():
+            try:
+                return await result
+            finally:
+                settle()
+
+        return settling_coroutine()
+    if inspect.isasyncgen(result):
+
+        async def settling_async_generator():
+            # driven by hand so asend()/athrow() reach the inner generator
+            value, error = None, None
+            try:
+                while True:
+                    try:
+                        if error is None:
+                            item = await result.asend(value)
+                        else:
+                            item = await result.athrow(error)
+                    except StopAsyncIteration:
+                        return
+                    value, error = None, None
+                    try:
+                        value = yield item
+                    except GeneratorExit:
+                        await result.aclose()
+                        raise
+                    except BaseException as e:
+                        error = e
+            finally:
+                settle()
+
+        return settling_async_generator()
+    return result
+
+
+def _call_then_settle(call: Callable[[], Any], settle: Callable[[], None]):
+    """``call()``, then ``settle()`` (see ``_settled``); also after a call that raised,
+    since it may have grown the object first."""
+    try:
+        result = call()
+    except BaseException:
+        settle()
+        raise
+    return _settled(result, settle)
+
+
 def _get_attr_value(obj, attr_name, is_dispatchable, /, **kwargs):
     if not is_dispatchable(obj, attr_name):
         raise InputError(

{py2http-0.1.69 → py2http-0.1.71}/py2http/tests/test_error_statuses.py

@@ -63,3 +63,41 @@ def test_aiohttp_error_handler(error, status):
     assert caught.value.status == status
     if status == 500:
         assert "internal detail" not in caught.value.text
+
+
+@pytest.mark.parametrize("error, status", CASES)
+def test_flask_error_handler(error, status, monkeypatch):
+    flask = pytest.importorskip("flask")
+    monkeypatch.delenv("PY2HTTP_WWW_AUTHENTICATE", raising=False)
+    monkeypatch.setenv("PY2HTTP_FRAMEWORK", "flask")
+    from py2http.default_configs import default_error_handler
+
+    app = flask.Flask(__name__)
+
+    @app.route("/fail")
+    def fail():
+        return default_error_handler(error)
+
+    response = app.test_client().get("/fail")
+    assert response.status_code == status
+    assert set(response.get_json()) == {"error"}
+    if status == 400:  # as the bottle handler: the status line names the error
+        assert response.status == f"400 {type(error).__name__}"
+    if status == 401:
+        assert response.headers["WWW-Authenticate"] == "Bearer"
+    else:
+        assert "WWW-Authenticate" not in response.headers
+    if status == 500:
+        assert "internal detail" in response.get_json()["error"]
+
+
+def test_flask_opaque_errors_hides_500_text(monkeypatch):
+    flask = pytest.importorskip("flask")
+    monkeypatch.setenv("OPAQUE_ERRORS", "1")
+    from py2http.default_configs import flask_error_handler
+
+    app = flask.Flask(__name__)
+    app.add_url_rule(
+        "/f", "f", lambda: flask_error_handler(KeyError("internal detail"))
+    )
+    assert app.test_client().get("/f").get_json() == {"error": "Internal server error"}

py2http-0.1.71/py2http/tests/test_obj_measuring.py

@@ -0,0 +1,263 @@
+"""Object endpoints: ``obj_readers`` skip measuring, lazy results are measured when
+they finish, module endpoints take an optional owner gate, and every 401 names a
+challenge (#32)."""
+
+import asyncio
+
+import pytest
+from aiohttp import web
+from i2.errors import AuthorizationError, InputError
+
+from py2http import mk_app
+from py2http.bottle_plugins import ApiKeyAuthPlugin, JWTPlugin
+from py2http.default_configs import aiohttp_error_handler
+from py2http.service import _get_func_to_dispatch_handler
+from py2http.tests.utils_for_testing import as_owner, call_wsgi
+
+
+class Store(dict):
+    def write(self, key, value):
+        self[key] = value
+
+    def read(self, key):
+        return self[key]
+
+    def fill_lazily(self, n):
+        for i in range(n):
+            self[i] = "y" * 1_000
+            yield i
+
+    async def fill_async(self, n):
+        for i in range(n):
+            self[i] = "y" * 1_000
+        return n
+
+
+class _Counting:
+    def __init__(self):
+        self.calls = 0
+
+    def __call__(self, obj, limit):
+        self.calls += 1
+        return len(obj)
+
+
+def _instance(store, **extras):
+    extras.setdefault("obj_owner", lambda req: req)
+    return _get_func_to_dispatch_handler(
+        dict(endpoint=store, name="store", attr_names="*", **extras)
+    )
+
+
+def test_obj_readers_are_not_measured():
+    sizeof = _Counting()
+    func = _instance(Store(), max_obj_size=10, obj_sizeof=sizeof, obj_readers={"read"})
+    built = sizeof.calls
+    as_owner("ann", func, _attr_name="write", key="a", value=1)
+    assert sizeof.calls == built + 1
+    for _ in range(5):
+        assert as_owner("ann", func, _attr_name="read", key="a") == 1
+    assert sizeof.calls == built + 1
+
+
+def test_class_endpoint_readers_are_not_measured():
+    sizeof = _Counting()
+    func = _get_func_to_dispatch_handler(
+        dict(
+            endpoint=Store,
+            name="bag",
+            attr_names="*",
+            obj_owner=lambda req: req,
+            obj_sizeof=sizeof,
+            obj_readers=["read"],
+        )
+    )
+    obj_id = as_owner("ann", func)
+    as_owner("ann", func, _obj_id=obj_id, _attr_name="write", key="a", value=1)
+    measured = sizeof.calls
+    as_owner("ann", func, _obj_id=obj_id, _attr_name="read", key="a")
+    assert sizeof.calls == measured
+
+
+@pytest.mark.parametrize(
+    "readers, error", [("read", TypeError), (["nope"], ValueError)]
+)
+def test_obj_readers_are_validated(readers, error):
+    with pytest.raises(error, match="obj_readers"):
+        _instance(Store(), obj_readers=readers)
+
+
+def test_a_generator_is_measured_when_it_finishes():
+    store = Store()
+    func = _instance(store, max_obj_size=5, obj_sizeof=lambda obj, limit: len(obj))
+    gen = as_owner("ann", func, _attr_name="fill_lazily", n=10)
+    assert store == {}  # nothing ran yet: measuring now would see nothing
+    with pytest.raises(InputError, match="size limit"):
+        list(gen)
+    with pytest.raises(InputError, match="size limit"):  # and the next call is refused
+        as_owner("ann", func, _attr_name="write", key="x", value=1)
+
+
+def test_a_coroutine_is_measured_when_it_finishes():
+    store = Store()
+    func = _instance(store, max_obj_size=5, obj_sizeof=lambda obj, limit: len(obj))
+    coro = as_owner("ann", func, _attr_name="fill_async", n=10)
+    with pytest.raises(InputError, match="size limit"):
+        asyncio.run(coro)
+
+
+def test_class_endpoint_drops_an_object_a_generator_grew():
+    func = _get_func_to_dispatch_handler(
+        dict(
+            endpoint=Store,
+            name="bag",
+            attr_names="*",
+            obj_owner=lambda req: req,
+            max_obj_size=5,
+            obj_sizeof=lambda obj, limit: len(obj),
+        )
+    )
+    obj_id = as_owner("ann", func)
+    gen = as_owner("ann", func, _obj_id=obj_id, _attr_name="fill_lazily", n=10)
+    with pytest.raises(InputError, match="dropped"):
+        list(gen)
+    with pytest.raises(InputError, match="No object"):
+        as_owner("ann", func, _obj_id=obj_id, _attr_name="read", key=0)
+
+
+def test_module_endpoint_takes_an_optional_owner_gate():
+    import os.path as module
+
+    gated = _get_func_to_dispatch_handler(
+        dict(endpoint=module, name="m", attr_names=["basename"], obj_owner=lambda r: r)
+    )
+    assert as_owner("ann", gated, _attr_name="basename", p="/a/b") == "b"
+    with pytest.raises(AuthorizationError):
+        as_owner(None, gated, _attr_name="basename", p="/a/b")
+
+
+# ---------------------------------------------------------------------------
+# 401 responses name a challenge (RFC 7235)
+# ---------------------------------------------------------------------------
+
+
+def _unidentified():
+    raise AuthorizationError("who are you")
+
+
+def test_a_raised_authorization_error_names_a_challenge(monkeypatch, capsys):
+    app = mk_app([_unidentified])
+    status, _, headers = call_wsgi(app, "/_unidentified", {}, with_headers=True)
+    assert status.startswith("401") and headers["www-authenticate"] == "Bearer"
+    monkeypatch.setenv("PY2HTTP_WWW_AUTHENTICATE", 'Basic realm="api"')
+    _, _, headers = call_wsgi(app, "/_unidentified", {}, with_headers=True)
+    assert headers["www-authenticate"] == 'Basic realm="api"'
+
+
+def test_aiohttp_401_names_a_challenge():
+    with pytest.raises(web.HTTPUnauthorized) as caught:
+        aiohttp_error_handler(AuthorizationError("who"))
+    assert caught.value.headers["WWW-Authenticate"] == "Bearer"
+    with pytest.raises(web.HTTPBadRequest) as caught:
+        aiohttp_error_handler(InputError("bad"))
+    assert "WWW-Authenticate" not in caught.value.headers
+
+
+def whoami():
+    return "me"
+
+
+@pytest.mark.parametrize(
+    "plugin, challenge",
+    [
+        (JWTPlugin("s3cret-for-tests-only-0123456789abcdef"), "Bearer"),
+        (ApiKeyAuthPlugin("api-key-for-tests-only"), "ApiKey"),
+    ],
+    ids=["jwt", "api-key"],
+)
+def test_auth_plugins_name_their_challenge(plugin, challenge):
+    app = mk_app([whoami], plugins=[plugin])
+    status, _, headers = call_wsgi(app, "/whoami", {}, with_headers=True)
+    assert status.startswith("401") and headers["www-authenticate"] == challenge
+
+
+def test_aiohttp_middlewares_name_their_challenge():
+    from py2http.middleware import _unauthorized
+
+    assert _unauthorized("x").headers["WWW-Authenticate"] == "Bearer"
+    assert _unauthorized("x", "ApiKey").headers["WWW-Authenticate"] == "ApiKey"
+
+
+# ---------------------------------------------------------------------------
+# Adversarial-review regressions
+# ---------------------------------------------------------------------------
+
+
+class Eager(dict):
+    def add(self, key):
+        self[key] = "x" * 1_000
+        return (k for k in [key])  # grows first, then returns a lazy result
+
+    async def echo(self):
+        got = None
+        while True:
+            got = yield got
+
+
+def test_growth_before_returning_a_lazy_result_is_measured_at_return():
+    store = Eager()
+    func = _instance(store, max_obj_size=3, obj_sizeof=lambda obj, limit: len(obj))
+    for i in range(3):
+        as_owner("ann", func, _attr_name="add", key=i)  # never consumed
+    with pytest.raises(InputError, match="size limit"):
+        as_owner("ann", func, _attr_name="add", key=3)
+
+
+def test_class_endpoint_drops_an_object_grown_before_a_lazy_return():
+    func = _get_func_to_dispatch_handler(
+        dict(
+            endpoint=Eager,
+            name="bag",
+            attr_names="*",
+            obj_owner=lambda req: req,
+            max_obj_size=1,
+            obj_sizeof=lambda obj, limit: len(obj),
+        )
+    )
+    obj_id = as_owner("ann", func)
+    as_owner("ann", func, _obj_id=obj_id, _attr_name="add", key=0)
+    with pytest.raises(InputError, match="dropped"):
+        as_owner("ann", func, _obj_id=obj_id, _attr_name="add", key=1)
+
+
+def test_a_wrapped_async_generator_forwards_asend():
+    func = _instance(Eager(), max_obj_size=None)
+
+    async def drive():
+        gen = as_owner("ann", func, _attr_name="echo")
+        await gen.asend(None)
+        got = await gen.asend(42)
+        await gen.aclose()
+        return got
+
+    assert asyncio.run(drive()) == 42
+
+
+def test_class_endpoint_readers_are_validated():
+    with pytest.raises(ValueError, match="obj_readers"):
+        _get_func_to_dispatch_handler(
+            dict(
+                endpoint=Store,
+                name="bag",
+                attr_names="*",
+                obj_owner=lambda req: req,
+                obj_readers=["raed"],
+            )
+        )
+
+
+def test_a_challenge_with_a_line_break_falls_back_to_bearer(monkeypatch):
+    from py2http.default_configs import www_authenticate_challenge
+
+    monkeypatch.setenv("PY2HTTP_WWW_AUTHENTICATE", "Basic\r\nSet-Cookie: x=1")
+    assert www_authenticate_challenge() == "Bearer"

{py2http-0.1.69 → py2http-0.1.71}/py2http/tests/utils_for_testing.py

@@ -32,9 +32,12 @@ def run_server(launcher, wait_before_entering=0, verbose=False, **kwargs):
         clog(f"... server terminated")
 
 
-def call_wsgi(app, path, payload=None, *, method="POST", headers=()):
+def call_wsgi(
+    app, path, payload=None, *, method="POST", headers=(), with_headers=False
+):
     """Send one request to the WSGI ``app`` in-process; return ``(status, body)``, the
-    body decoded from JSON when it is JSON.
+    body decoded from JSON when it is JSON (``(status, body, response_headers)`` with
+    ``with_headers``, header names lower-cased).
 
     ``headers`` maps header names (``"Authorization"``) to values.
     """
@@ -49,12 +52,20 @@ def call_wsgi(app, path, payload=None, *, method="POST", headers=()):
     for name, value in dict(headers).items():
         environ["HTTP_" + name.upper().replace("-", "_")] = value
     setup_testing_defaults(environ)
-    statuses = []
-    out = b"".join(app(environ, lambda status, headers, *a: statuses.append(status)))
+    statuses, response_headers = [], {}
+
+    def start_response(status, headers, *a):
+        statuses.append(status)
+        response_headers.update((k.lower(), v) for k, v in headers)  # case-insensitive
+
+    out = b"".join(app(environ, start_response))
     try:
-        return statuses[0], json.loads(out)
+        body = json.loads(out)
     except ValueError:
-        return statuses[0], out.decode()
+        body = out.decode()
+    if with_headers:
+        return statuses[0], body, response_headers
+    return statuses[0], body
 
 
 def as_owner(owner, func, **kwargs):

{py2http-0.1.69 → py2http-0.1.71}/py2http.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py2http
-Version: 0.1.69
+Version: 0.1.71
 Summary: Declarative HTTP service entry point.
 Home-page: https://github.com/i2mint/py2http
 License: MIT

{py2http-0.1.69 → py2http-0.1.71}/py2http.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ py2http/tests/test_flask.py
 py2http/tests/test_instance_endpoints.py
 py2http/tests/test_jwt_middleware.py
 py2http/tests/test_not_set_defaults.py
+py2http/tests/test_obj_measuring.py
 py2http/tests/test_obj_ownership.py
 py2http/tests/test_p2h2p.py
 py2http/tests/test_positional_only.py

{py2http-0.1.69 → py2http-0.1.71}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = py2http
-version = 0.1.69
+version = 0.1.71
 url = https://github.com/i2mint/py2http
 root_url = https://github.com/i2mint
 platforms = any