123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250 |
- # -*- coding: utf-8 -*-
- """
- flask.testing
- ~~~~~~~~~~~~~
- Implements test support helpers. This module is lazily imported
- and usually not used in production environments.
- :copyright: © 2010 by the Pallets team.
- :license: BSD, see LICENSE for more details.
- """
- import werkzeug
- from contextlib import contextmanager
- from click.testing import CliRunner
- from flask.cli import ScriptInfo
- from werkzeug.test import Client, EnvironBuilder
- from flask import _request_ctx_stack
- from flask.json import dumps as json_dumps
- from werkzeug.urls import url_parse
- def make_test_environ_builder(
- app, path='/', base_url=None, subdomain=None, url_scheme=None,
- *args, **kwargs
- ):
- """Create a :class:`~werkzeug.test.EnvironBuilder`, taking some
- 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`.
- """
- 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 = '{0}.{1}'.format(subdomain, http_host)
- if url_scheme is None:
- url_scheme = app.config['PREFERRED_URL_SCHEME']
- url = url_parse(path)
- base_url = '{scheme}://{netloc}/{path}'.format(
- scheme=url.scheme or url_scheme,
- netloc=url.netloc or http_host,
- path=app_root.lstrip('/')
- )
- path = url.path
- if url.query:
- sep = b'?' if isinstance(url.query, bytes) else '?'
- path += sep + url.query
- if 'json' in kwargs:
- assert 'data' not in kwargs, (
- "Client cannot provide both 'json' and 'data'."
- )
- # push a context so flask.json can use app's json attributes
- with app.app_context():
- kwargs['data'] = json_dumps(kwargs.pop('json'))
- if 'content_type' not in kwargs:
- kwargs['content_type'] = 'application/json'
- return EnvironBuilder(path, base_url, *args, **kwargs)
- class FlaskClient(Client):
- """Works like a regular Werkzeug test client but has some knowledge about
- how Flask works to defer the cleanup of the request context stack to the
- end of a ``with`` body when used in a ``with`` statement. For general
- information about how to use this class refer to
- :class:`werkzeug.test.Client`.
- .. versionchanged:: 0.12
- `app.test_client()` includes preset default environment, which can be
- set after instantiation of the `app.test_client()` object in
- `client.environ_base`.
- Basic usage is outlined in the :ref:`testing` chapter.
- """
- preserve_context = False
- def __init__(self, *args, **kwargs):
- super(FlaskClient, self).__init__(*args, **kwargs)
- self.environ_base = {
- "REMOTE_ADDR": "127.0.0.1",
- "HTTP_USER_AGENT": "werkzeug/" + werkzeug.__version__
- }
- @contextmanager
- def session_transaction(self, *args, **kwargs):
- """When used in combination with a ``with`` statement this opens a
- session transaction. This can be used to modify the session that
- the test client uses. Once the ``with`` block is left the session is
- stored back.
- ::
- with client.session_transaction() as session:
- session['value'] = 42
- Internally this is implemented by going through a temporary test
- request context and since session handling could depend on
- request variables this function accepts the same arguments as
- :meth:`~flask.Flask.test_request_context` which are directly
- passed through.
- """
- if self.cookie_jar is None:
- raise RuntimeError('Session transactions only make sense '
- 'with cookies enabled.')
- app = self.application
- environ_overrides = kwargs.setdefault('environ_overrides', {})
- self.cookie_jar.inject_wsgi(environ_overrides)
- outer_reqctx = _request_ctx_stack.top
- with app.test_request_context(*args, **kwargs) as c:
- session_interface = app.session_interface
- sess = session_interface.open_session(app, c.request)
- if sess is None:
- raise RuntimeError('Session backend did not open a session. '
- 'Check the configuration')
- # Since we have to open a new request context for the session
- # handling we want to make sure that we hide out own context
- # from the caller. By pushing the original request context
- # (or None) on top of this and popping it we get exactly that
- # behavior. It's important to not use the push and pop
- # methods of the actual request context object since that would
- # mean that cleanup handlers are called
- _request_ctx_stack.push(outer_reqctx)
- try:
- yield sess
- finally:
- _request_ctx_stack.pop()
- resp = app.response_class()
- if not session_interface.is_null_session(sess):
- session_interface.save_session(app, sess, resp)
- headers = resp.get_wsgi_headers(c.request.environ)
- self.cookie_jar.extract_wsgi(c.request.environ, headers)
- def open(self, *args, **kwargs):
- as_tuple = kwargs.pop('as_tuple', False)
- buffered = kwargs.pop('buffered', False)
- follow_redirects = kwargs.pop('follow_redirects', False)
- if (
- not kwargs and len(args) == 1
- and isinstance(args[0], (EnvironBuilder, dict))
- ):
- environ = self.environ_base.copy()
- if isinstance(args[0], EnvironBuilder):
- environ.update(args[0].get_environ())
- else:
- environ.update(args[0])
- environ['flask._preserve_context'] = self.preserve_context
- else:
- kwargs.setdefault('environ_overrides', {}) \
- ['flask._preserve_context'] = self.preserve_context
- kwargs.setdefault('environ_base', self.environ_base)
- builder = make_test_environ_builder(
- self.application, *args, **kwargs
- )
- try:
- environ = builder.get_environ()
- finally:
- builder.close()
- return Client.open(
- self, environ,
- as_tuple=as_tuple,
- buffered=buffered,
- follow_redirects=follow_redirects
- )
- def __enter__(self):
- if self.preserve_context:
- raise RuntimeError('Cannot nest client invocations')
- self.preserve_context = True
- return self
- def __exit__(self, exc_type, exc_value, tb):
- self.preserve_context = False
- # on exit we want to clean up earlier. Normally the request context
- # stays preserved until the next request in the same thread comes
- # in. See RequestGlobals.push() for the general behavior.
- top = _request_ctx_stack.top
- if top is not None and top.preserved:
- top.pop()
- class FlaskCliRunner(CliRunner):
- """A :class:`~click.testing.CliRunner` for testing a Flask app's
- CLI commands. Typically created using
- :meth:`~flask.Flask.test_cli_runner`. See :ref:`testing-cli`.
- """
- def __init__(self, app, **kwargs):
- self.app = app
- super(FlaskCliRunner, self).__init__(**kwargs)
- def invoke(self, cli=None, args=None, **kwargs):
- """Invokes a CLI command in an isolated environment. See
- :meth:`CliRunner.invoke <click.testing.CliRunner.invoke>` for
- full method documentation. See :ref:`testing-cli` for examples.
- If the ``obj`` argument is not given, passes an instance of
- :class:`~flask.cli.ScriptInfo` that knows how to load the Flask
- app being tested.
- :param cli: Command object to invoke. Default is the app's
- :attr:`~flask.app.Flask.cli` group.
- :param args: List of strings to invoke the command with.
- :return: a :class:`~click.testing.Result` object.
- """
- if cli is None:
- cli = self.app.cli
- if 'obj' not in kwargs:
- kwargs['obj'] = ScriptInfo(create_app=lambda: self.app)
- return super(FlaskCliRunner, self).invoke(cli, args, **kwargs)
|