Source code
from __future__ import annotations
import importlib.metadata
import typing as t
from contextlib import contextmanager
from contextlib import ExitStack
from copy import copy
from types import TracebackType
from urllib.parse import urlsplit
import werkzeug.test
from click.testing import CliRunner
from click.testing import Result
from werkzeug.test import Client
from werkzeug.wrappers import Request as BaseRequest
from .cli import ScriptInfo
from .sessions import SessionMixin
class EnvironBuilder(werkzeug.test.EnvironBuilder):
"""An :class:`~werkzeug.test.EnvironBuilder`, that takes defaults from the
application.
:param app: The Flask application to configure the environment from.
:param path: URL path being requested.
:param base_url: Base URL where the app is being served, which
``path`` is relative to. If not given, built from
:data:`PREFERRED_URL_SCHEME`, ``subdomain``,
:data:`SERVER_NAME`, and :data:`APPLICATION_ROOT`.
:param subdomain: Subdomain name to append to :data:`SERVER_NAME`.
:param url_scheme: Scheme to use instead of
:data:`PREFERRED_URL_SCHEME`.
:param json: If given, this is serialized as JSON and passed as
``data``. Also defaults ``content_type`` to
``application/json``.
:param args: other positional arguments passed to
:class:`~werkzeug.test.EnvironBuilder`.
:param kwargs: other keyword arguments passed to
:class:`~werkzeug.test.EnvironBuilder`.
"""
def __init__(
self,
app: Flask,
path: str = "/",
base_url: str | None = None,
subdomain: str | None = None,
url_scheme: str | None = None,
*args: t.Any,
**kwargs: t.Any,
) -> None:
assert not (base_url or subdomain or url_scheme) or (
base_url is not None
) != bool(subdomain or url_scheme), (
'Cannot pass "subdomain" or "url_scheme" with "base_url".'
)
if base_url is None:
http_host = app.config.get("SERVER_NAME") or "localhost"
app_root = app.config["APPLICATION_ROOT"]
if subdomain:
http_host = f"{subdomain}.{http_host}"
if url_scheme is None:
url_scheme = app.config["PREFERRED_URL_SCHEME"]
url = urlsplit(path)
base_url = (
f"{url.scheme or url_scheme}://{url.netloc or http_host}"
f"/{app_root.lstrip('/')}"
)
path = url.path
if url.query:
path = f"{path}?{url.query}"
self.app = app
super().__init__(path, base_url, *args, **kwargs)
def json_dumps(self, obj: t.Any, **kwargs: t.Any) -> str:
"""Serialize ``obj`` to a JSON-formatted string.
The serialization will be configured according to the config associated
with this EnvironBuilder's ``app``.
"""
return self.app.json.dumps(obj, **kwargs)
Run 1
The code is generally readable and well-organized. The class has a clear purpose, the docstring is helpful, and the method logic is logically structured. The assertion statement, however, is somewhat complex and hard to parse, reducing clarity. Nesting is minimal, and most code is at the method level. The `__init__` method contains a few multi-step operations (e.g., building the base URL and path) that are reasonably concise but could be slightly clearer with helper methods. Action granularity is mostly one action per line, but the assertion and URL-building lines bundle multiple operations, slightly reducing readability. Reading flow is natural overall, with imports and method ordering following common patterns.
Run 2
The code is well-structured and readable. The class has a clear purpose, inheriting from werkzeug's EnvironBuilder and adding Flask-specific configuration. The __init__ method is logically organized with clear conditional blocks for URL construction. Docstrings are thorough and helpful. Type hints improve clarity. The assert statement is somewhat complex but includes an explanatory message. Variable names are descriptive. The json_dumps method is concise and delegates properly. Minor readability concerns include the multi-condition assert being slightly dense and the base_url f-string spanning multiple lines with mixed string concatenation, which could be simplified. Overall, the code maintains flat nesting, one logical action per line, and follows a natural reading flow.
Run 3
The code is generally well-structured and readable, with good separation of concerns and docstrings. However, it is docked points for over-nesting and multi-action lines. The conditional logic in the constructor is nested three levels deep, making the flow harder to follow. Lines like `assert not (base_url or subdomain or url_scheme) or ...` combine several boolean checks into one expression, reducing clarity. Similarly, the URL construction line packs multiple actions (checking scheme, netloc, app_root lstrip) into a single f-string. The class itself is cohesive, and the `json_dumps` method is clear and concise, but the constructor complexity is a readability hurdle. The use of type hints and consistent formatting improves clarity. Overall, it scores above average due to good naming and docstring quality, but loses points for unnecessary nesting and compact expressions.
Run 1
Code Structure: Well organized into a focused class with initialization and JSON serialization clearly separated; several unused imports add clutter. Nesting: Shallow conditionals keep the control flow easy to follow. Clarity of intent: Descriptive names, type annotations, and detailed docstrings explain the purpose, but the compound assertion is unnecessarily difficult to parse, and Flask is not imported in the snippet. Code length: The implementation is concise; documentation is useful but lengthy relative to the logic. Action granularity: Most lines perform one clear action, with sensible multiline formatting for signatures and URL construction. Reading flow: Configuration lookup, URL assembly, and superclass initialization follow a natural sequence, although the initial assertion interrupts that flow.
Run 2
Code Structure: Well organized into a focused class with initialization and serialization methods, although several imports appear unused in this snippet. Nesting: Shallow conditional nesting keeps control flow easy to follow. Clarity of intent: Descriptive names, type annotations, and detailed documentation explain application-derived URL defaults; however, the compound assertion is difficult to parse, and Flask is not imported in the excerpt. Code length: Implementation is reasonably concise, though the documentation and import list occupy substantial space. Action granularity: Statements generally perform one action per line, with sensible multiline formatting for signatures and expressions. Reading flow: Configuration lookup, URL construction, and superclass initialization follow a natural sequence; the dense validation expression briefly interrupts that flow.
Run 3
Code Structure: Logically organized into a focused class with initialization and serialization methods, although numerous unused imports add clutter. Nesting: Shallow, with straightforward conditionals inside one main branch. Clarity of intent: Descriptive names, type annotations, and documentation explain the purpose well; the compound assertion is harder to interpret than a direct conditional. Code length: Implementation is reasonably concise, though the extensive docstring and unused imports increase reading overhead. Action granularity: Statements generally perform one action per line, with multiline expressions formatted clearly. Reading flow: Configuration lookup, URL construction, and superclass initialization follow a natural sequence. The dense assertion and Flask annotation without a visible import slightly interrupt comprehension.