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 with clear class hierarchy and logical organization. Imports are grouped and typed. The constructor uses a flat, readable flow with minimal nesting. The base_url construction logic is clearly segmented and well-commented. However, the initial assertion condition is overly complex and hard to parse at a glance, mixing boolean logic with string concatenation. Type hints improve clarity, but the long conditional expression reduces readability. Method-level docstrings are helpful. Overall, the code is maintainable but could benefit from simplifying the assertion into a helper method or clearer conditional blocks.
Run 3
The code is highly readable. It has a clear logical structure: imports are organized, the class has a focused responsibility, and methods are concise. Nesting is minimal — the constructor uses one conditional block with straightforward logic. The intent is well-documented with a thorough docstring explaining parameters and behavior. Code length is appropriate for the functionality; the docstring is verbose but justified by the complexity of parameter interactions. Action granularity is mostly one logical action per line, though the assertion line is long and packs multiple conditions into a single expression, slightly reducing readability. Reading flow is natural: the docstring explains the class, then the constructor proceeds step-by-step from validation to URL construction. Minor improvements could include splitting the assertion into named boolean variables, but overall the code is clean, self-documenting, and easy to follow.
Run 1
Code Structure: Logically organized into a focused class with initialization and a separate serialization method; several unused imports add clutter. Nesting: Mostly shallow, with straightforward conditionals inside the base-URL setup. Clarity of intent: Descriptive names, type annotations, and detailed documentation explain the purpose well, but the compound assertion is difficult to parse, and Flask is not imported in the shown snippet. Code length: Implementation is concise; the lengthy docstring is useful rather than redundant, though the imports are excessive for this excerpt. Action granularity: Statements generally perform one action per line, with sensible multiline formatting for signatures and URL construction. Reading flow: Configuration lookup, URL construction, and superclass initialization follow a natural sequence; the assertion briefly interrupts that flow.
Run 2
Code Structure: Clearly organized into a documented class, initialization logic, and a focused serialization method, though several imports appear unused in this snippet. Nesting: Shallow conditional nesting is easy to follow. Clarity of intent: Descriptive names, type annotations, and comprehensive docstrings explain application-derived defaults; however, the compound assertion is harder to decipher than a straightforward validation condition. Code length: Implementation is reasonably concise, while the extensive documentation adds useful context rather than unnecessary logic. Action granularity: Statements generally perform one action each, with multiline expressions formatted cleanly. Reading flow: Initialization progresses naturally from validation to URL construction and superclass setup. The missing visible Flask import and dense assertion slightly interrupt otherwise smooth reading.
Run 3
Code Structure: Imports, class documentation, initialization, and serialization are logically organized, although several imports appear unused in this excerpt. Nesting: Control flow is shallow, with only a few conditionals inside the base URL construction block. Clarity of intent: Descriptive names, type annotations, and detailed docstrings clearly explain application-derived defaults; however, the compound assertion is unnecessarily difficult to interpret. Code length: Implementation is concise and proportionate to its purpose, though the documentation and imports add substantial length. Action granularity: Statements generally perform one action per line, with sensible multiline formatting for signatures and URL construction. Reading flow: Execution naturally progresses from argument validation through default resolution and URL normalization to superclass initialization. The dense assertion briefly interrupts that flow.