Testing

Included pytest fixtures

app

flask_unchained.pytest.app(request)

Automatically used test fixture. Returns the application instance-under-test with a valid app context.

maybe_inject_extensions_and_services

flask_unchained.pytest.maybe_inject_extensions_and_services(app, request)

Automatically used test fixture. Allows for using services and extensions as if they were test fixtures:

def test_something(db, mail, security_service, user_manager):
    # assert important stuff

NOTE: This only works on tests themselves; it will not work on test fixtures

cli_runner

flask_unchained.pytest.cli_runner(app)

Yields an instance of FlaskCliRunner. Example usage:

from your_package.commands import some_command

def test_some_command(cli_runner):
    result = cli_runner.invoke(some_command)
    assert result.exit_code == 0
    assert result.output.strip() == 'output of some_command'

client

flask_unchained.pytest.client(app)

Yields an instance of HtmlTestClient. Example usage:

def test_some_view(client):
    r = client.get('some.endpoint')

    # r is an instance of :class:`HtmlTestResponse`
    assert r.status_code == 200
    assert 'The Page Title' in r.html

api_client

flask_unchained.pytest.api_client(app)

Yields an instance of ApiTestClient. Example usage:

def test_some_view(api_client):
    r = api_client.get('some.endpoint.returning.json')

    # r is an instance of :class:`ApiTestResponse`
    assert r.status_code == 200
    assert 'some_key' in r.json

templates

flask_unchained.pytest.templates(app)

Fixture to record which templates (if any) got rendered during a request. Example Usage:

def test_some_view(client, templates):
    r = client.get('some.endpoint')
    assert r.status_code == 200
    assert templates[0].template.name == 'some/template.html'
    assert templates[0].context.get('some_ctx_var') == 'expected value'

Testing related classes

FlaskCliRunner

class flask_unchained.pytest.FlaskCliRunner(app, **kwargs)

Extended from upstream to run commands within the Flask app context.

The CLI runner provides functionality to invoke a Click command line script for unit testing purposes in a isolated environment. This only works in single-threaded systems without any concurrency as it changes the global interpreter state.

Parameters

• charset – the character set for the input and output data. This is UTF-8 by default and should not be changed currently as the reporting to Click only works in Python 2 properly.

• env – a dictionary with environment variables for overriding.

• echo_stdin – if this is set to True, then reading from stdin writes to stdout. This is useful for showing examples in some circumstances. Note that regular prompts will automatically echo the input.

invoke(cli=None, args=None, **kwargs)

Invokes a command in an isolated environment. The arguments are forwarded directly to the command line script, the extra keyword arguments are passed to the main() function of the command.

This returns a Result object.

Parameters

• cli – the command to invoke

• args – the arguments to invoke

• input – the input data for sys.stdin.

• env – the environment overrides.

• catch_exceptions – Whether to catch any other exceptions than SystemExit.

• extra – the keyword arguments to pass to main().

• color – whether the output should contain color codes. The application can still override this explicitly.

HtmlTestClient

class flask_unchained.pytest.HtmlTestClient(*args: Any, **kwargs: Any)

Like FlaskClient, except it supports passing an endpoint as the first argument directly to the HTTP get/post/etc methods (no need to use url_for, unless your URL rule has parameter names that conflict with the keyword arguments of EnvironBuilder). It also adds support for following redirects. Example usage:

def test_something(client: HtmlTestClient):
    r = client.get('site_controller.index')
    assert r.status_code == 200

follow_redirects(response)

Follow redirects on a response after inspecting it. Example usage:

def test_some_view(client):
    r = client.post('some.endpoint.that.redirects', data=data)
    assert r.status_code == 302
    assert r.path == url_for('some.endpoint')

    r = client.follow_redirects(r)
    assert r.status_code == 200

HtmlTestResponse

class flask_unchained.pytest.HtmlTestResponse(response: Union[Iterable[bytes], bytes, Iterable[str], str, None] = None, status: Union[int, str, http.HTTPStatus, None] = None, headers: Union[Mapping[str, Union[str, int, Iterable[Union[str, int]]]], Iterable[Tuple[str, Union[str, int]]], None] = None, mimetype: Optional[str] = None, content_type: Optional[str] = None, direct_passthrough: bool = False)

Like flask.wrappers.Response, except extended with methods for inspecting the parsed URL and automatically decoding the response to a string.

property scheme

Returns the URL scheme specifier of the response’s url, eg http or https.

property netloc

Returns the network location part the response’s url.

property path

Returns the path part of the response’s url.

property params

Returns the parameters for the last path element in the response’s url.

property query

Returns the query component from the response’s url.

property fragment

Returns the fragment identifier from the response’s url.

property html

Returns the response’s data parsed to a string of html.

ApiTestClient

class flask_unchained.pytest.ApiTestClient(*args: Any, **kwargs: Any)

Like HtmlTestClient except it supports automatic serialization to json of data, as well as setting the Accept and Content-Type headers to application/json.

open(*args, **kwargs)

Generate an environ dict from the given arguments, make a request to the application using it, and return the response.

Parameters

• args – Passed to EnvironBuilder to create the environ for the request. If a single arg is passed, it can be an existing EnvironBuilder or an environ dict.

• buffered – Convert the iterator returned by the app into a list. If the iterator has a close() method, it is called automatically.

• follow_redirects – Make additional requests to follow HTTP redirects until a non-redirect status is returned. TestResponse.history lists the intermediate responses.

Changed in version 2.0: as_tuple is deprecated and will be removed in Werkzeug 2.1. Use TestResponse.request and request.environ instead.

Changed in version 2.0: The request input stream is closed when calling response.close(). Input streams for redirects are automatically closed.

Changed in version 0.5: If a dict is provided as file in the dict for the data parameter the content type has to be called content_type instead of mimetype. This change was made for consistency with werkzeug.FileWrapper.

Changed in version 0.5: Added the follow_redirects parameter.

ApiTestResponse

class flask_unchained.pytest.ApiTestResponse(response: Union[Iterable[bytes], bytes, Iterable[str], str, None] = None, status: Union[int, str, http.HTTPStatus, None] = None, headers: Union[Mapping[str, Union[str, int, Iterable[Union[str, int]]]], Iterable[Tuple[str, Union[str, int]]], None] = None, mimetype: Optional[str] = None, content_type: Optional[str] = None, direct_passthrough: bool = False)

Like HtmlTestResponse except it adds methods for automatically parsing the response data as json and retrieving errors from the response data.

property json

Returns the response’s data parsed from json.

property errors

If the response contains the key errors, return its value, otherwise returns an empty dictionary.

RenderedTemplate

class flask_unchained.pytest.RenderedTemplate(template, context)

A namedtuple returned by the templates() fixture.

property context

Alias for field number 1

property template

Alias for field number 0