import os
from unittest import mock
import pytest
import httpretty as _httpretty
from cloudinit import helpers, subp
class _FixtureUtils:
"""A namespace for fixture helper functions, used by fixture_utils.
These helper functions are all defined as staticmethods so they are
effectively functions; they are defined in a class only to give us a
namespace so calling them can look like
``fixture_utils.fixture_util_function()`` in test code.
"""
@staticmethod
def closest_marker_args_or(request, marker_name: str, default):
"""Get the args for closest ``marker_name`` or return ``default``
:param request:
A pytest request, as passed to a fixture.
:param marker_name:
The name of the marker to look for
:param default:
The value to return if ``marker_name`` is not found.
:return:
The args for the closest ``marker_name`` marker, or ``default``
if no such marker is found.
"""
try:
marker = request.node.get_closest_marker(marker_name)
except AttributeError:
# Older versions of pytest don't have the new API
marker = request.node.get_marker(marker_name)
if marker is not None:
return marker.args
return default
@staticmethod
def closest_marker_first_arg_or(request, marker_name: str, default):
"""Get the first arg for closest ``marker_name`` or return ``default``
This is a convenience wrapper around closest_marker_args_or, see there
for full details.
"""
result = _FixtureUtils.closest_marker_args_or(
request, marker_name, [default]
)
if not result:
raise TypeError(
"Missing expected argument to {} marker".format(marker_name)
)
return result[0]
@pytest.yield_fixture(autouse=True)
def disable_subp_usage(request, fixture_utils):
"""
Across all (pytest) tests, ensure that subp.subp is not invoked.
Note that this can only catch invocations where the util module is imported
and ``subp.subp(...)`` is called. ``from cloudinit.subp mport subp``
imports happen before the patching here (or the CiTestCase monkey-patching)
happens, so are left untouched.
To allow a particular test method or class to use subp.subp you can mark it
as such::
@pytest.mark.allow_all_subp
def test_whoami(self):
subp.subp(["whoami"])
To instead allow subp.subp usage for a specific command, you can use the
``allow_subp_for`` mark::
@pytest.mark.allow_subp_for("bash")
def test_bash(self):
subp.subp(["bash"])
You can pass multiple commands as values; they will all be permitted::
@pytest.mark.allow_subp_for("bash", "whoami")
def test_several_things(self):
subp.subp(["bash"])
subp.subp(["whoami"])
This fixture (roughly) mirrors the functionality of
CiTestCase.allowed_subp. N.B. While autouse fixtures do affect non-pytest
tests, CiTestCase's allowed_subp does take precedence (and we have
TestDisableSubpUsageInTestSubclass to confirm that).
"""
allow_subp_for = fixture_utils.closest_marker_args_or(
request, "allow_subp_for", None
)
# Because the mark doesn't take arguments, `allow_all_subp` will be set to
# [] if the marker is present, so explicit None checks are required
allow_all_subp = fixture_utils.closest_marker_args_or(
request, "allow_all_subp", None
)
if allow_all_subp is not None and allow_subp_for is None:
# Only allow_all_subp specified, don't mock subp.subp
yield
return
if allow_all_subp is None and allow_subp_for is None:
# No marks, default behaviour; disallow all subp.subp usage
def side_effect(args, *other_args, **kwargs):
raise AssertionError("Unexpectedly used subp.subp")
elif allow_all_subp is not None and allow_subp_for is not None:
# Both marks, ambiguous request; raise an exception on all subp usage
def side_effect(args, *other_args, **kwargs):
raise AssertionError(
"Test marked both allow_all_subp and allow_subp_for: resolve"
" this either by modifying your test code, or by modifying"
" disable_subp_usage to handle precedence."
)
else:
# Look this up before our patch is in place, so we have access to
# the real implementation in side_effect
real_subp = subp.subp
def side_effect(args, *other_args, **kwargs):
cmd = args[0]
if cmd not in allow_subp_for:
raise AssertionError(
"Unexpectedly used subp.subp to call {} (allowed:"
" {})".format(cmd, ",".join(allow_subp_for))
)
return real_subp(args, *other_args, **kwargs)
with mock.patch("cloudinit.subp.subp", autospec=True) as m_subp:
m_subp.side_effect = side_effect
yield
@pytest.fixture(scope="session")
def fixture_utils():
"""Return a namespace containing fixture utility functions.
See :py:class:`_FixtureUtils` for further details."""
return _FixtureUtils
@pytest.yield_fixture
def httpretty():
"""
Enable HTTPretty for duration of the testcase, resetting before and after.
This will also ensure allow_net_connect is set to False, and temporarily
unset http_proxy in os.environ if present (to work around
https://github.com/gabrielfalcao/HTTPretty/issues/122).
"""
restore_proxy = os.environ.pop("http_proxy", None)
_httpretty.HTTPretty.allow_net_connect = False
_httpretty.reset()
_httpretty.enable()
yield _httpretty
_httpretty.disable()
_httpretty.reset()
if restore_proxy is not None:
os.environ["http_proxy"] = restore_proxy
@pytest.fixture
def paths(tmpdir):
"""
Return a helpers.Paths object configured to use a tmpdir.
(This uses the builtin tmpdir fixture.)
"""
dirs = {
"cloud_dir": tmpdir.mkdir("cloud_dir").strpath,
"run_dir": tmpdir.mkdir("run_dir").strpath,
}
return helpers.Paths(dirs)