def test_inline_cursor(calc):
monkeypatch().setattr(config, 'IMAGES_ROOT', os.path.join(config.PROJECT_ROOT, 'tests/files/cursors'))
f = open(os.path.join(config.PROJECT_ROOT, 'tests/files/cursors/fake.base64.txt'), 'rb')
font_base64 = f.read()
f.close()
assert 'url(data:image/cur;base64,%s)' % font_base64 == calc('inline_image("/fake.cur")').render()
def test_inline_cursor(calc):
monkeypatch().setattr(config, 'IMAGES_ROOT', os.path.join(config.PROJECT_ROOT, 'tests/files/cursors'))
f = open(os.path.join(config.PROJECT_ROOT, 'tests/files/cursors/fake.base64.txt'), 'rb')
font_base64 = f.read()
f.close()
assert 'url(data:image/cur;base64,%s)' % font_base64 == calc('inline_image("/fake.cur")').render()
def is_called(self, method, test_func, *args, **kwargs):
from _pytest.monkeypatch import monkeypatch
def called_func(*args, **kwargs):
self.called[method] = True
self.called[method] = False
monkeypatch().setattr(method, called_func)
test_func(*args, **kwargs)
return self.called[method]
def monkeypatch_sess(request):
"""Like `monkeypatch` fixture, but for sessions.
"""
from _pytest import monkeypatch
if pytest.__version__ < "3":
mpatch = monkeypatch.monkeypatch()
else:
mpatch = monkeypatch.monkeypatch(request)
request.addfinalizer(mpatch.undo)
return mpatch
def monkeypatch_sess(request):
"""Like `monkeypatch` fixture, but for sessions.
"""
from _pytest import monkeypatch
if pytest.__version__ < "3":
mpatch = monkeypatch.monkeypatch()
else:
mpatch = monkeypatch.monkeypatch(request)
request.addfinalizer(mpatch.undo)
return mpatch
def test_inline_font_files(calc):
"""
@author: funvit
@note: adapted from compass / test / units / sass_extensions_test.rb
"""
monkeypatch().setattr(config, 'FONTS_ROOT', os.path.join(config.PROJECT_ROOT, 'tests/files/fonts'))
with open(os.path.join(config.PROJECT_ROOT, 'tests/files/fonts/bgrove.base64.txt'), 'r') as f:
font_base64 = ''.join((f.readlines()))
assert 'url(data:font/truetype;base64,%s) format("truetype")' % font_base64 == calc('inline_font_files("/bgrove.ttf", truetype)').render()
def test_inline_image(calc):
monkeypatch().setattr(
config, 'IMAGES_ROOT',
os.path.join(config.PROJECT_ROOT, 'tests/files/images'))
with open(
os.path.join(config.PROJECT_ROOT,
'tests/files/images/test-qr.base64.txt'), 'r') as f:
font_base64 = f.read()
assert 'url(data:image/png;base64,%s)' % font_base64 == calc(
'inline_image("/test-qr.png")').render()
def pytest_configure(config):
mode = config.getvalue("assertmode")
if config.getvalue("noassert") or config.getvalue("nomagic"):
mode = "plain"
if mode == "rewrite":
try:
import ast
except ImportError:
mode = "reinterp"
else:
if sys.platform.startswith('java'):
mode = "reinterp"
if mode != "plain":
_load_modules(mode)
m = monkeypatch()
config._cleanup.append(m.undo)
m.setattr(py.builtin.builtins, 'AssertionError',
reinterpret.AssertionError)
hook = None
if mode == "rewrite":
hook = rewrite.AssertionRewritingHook()
sys.meta_path.insert(0, hook)
warn_about_missing_assertion(mode)
config._assertstate = AssertionState(config, mode)
config._assertstate.hook = hook
config._assertstate.trace("configured with mode set to %r" % (mode, ))
def pytest_configure(config):
mode = config.getvalue("assertmode")
if config.getvalue("noassert") or config.getvalue("nomagic"):
mode = "plain"
if mode == "rewrite":
try:
import ast
except ImportError:
mode = "reinterp"
else:
# Both Jython and CPython 2.6.0 have AST bugs that make the
# assertion rewriting hook malfunction.
if (sys.platform.startswith('java') or
sys.version_info[:3] == (2, 6, 0)):
mode = "reinterp"
if mode != "plain":
_load_modules(mode)
m = monkeypatch()
config._cleanup.append(m.undo)
m.setattr(py.builtin.builtins, 'AssertionError',
reinterpret.AssertionError)
hook = None
if mode == "rewrite":
hook = rewrite.AssertionRewritingHook()
sys.meta_path.insert(0, hook)
warn_about_missing_assertion(mode)
config._assertstate = AssertionState(config, mode)
config._assertstate.hook = hook
config._assertstate.trace("configured with mode set to %r" % (mode,))
def getfuncargvalue(self, argname):
""" Retrieve a function argument by name for this test
function invocation. This allows one function argument factory
to call another function argument factory. If there are two
funcarg factories for the same test function argument the first
factory may use ``getfuncargvalue`` to call the second one and
do something additional with the resource.
"""
try:
return self._funcargs[argname]
except KeyError:
pass
if argname not in self._name2factory:
self._name2factory[argname] = self.config.pluginmanager.listattr(
plugins=self._plugins,
attrname=self._argprefix + str(argname)
)
#else: we are called recursively
if not self._name2factory[argname]:
self._raiselookupfailed(argname)
funcargfactory = self._name2factory[argname].pop()
oldarg = self._currentarg
mp = monkeypatch()
mp.setattr(self, '_currentarg', argname)
try:
param = self._pyfuncitem.callspec.getparam(argname)
except (AttributeError, ValueError):
pass
else:
mp.setattr(self, 'param', param, raising=False)
try:
self._funcargs[argname] = res = funcargfactory(request=self)
finally:
mp.undo()
return res
def setup(self):
from _pytest.monkeypatch import monkeypatch
patch = monkeypatch()
patch.setattr('pymongo.MongoClient', mongomock.MongoClient)
from helga_karma import plugin
self.plugin = plugin
def _prepare(self):
self.counters = {}
basename = None
cli_tempdir_basename = self.config.getvalue('tempdir_basename')
if cli_tempdir_basename is not None:
basename = cli_tempdir_basename
else:
# Let's see if we have a pytest_tempdir_basename hook implementation
basename = self.config.hook.pytest_tempdir_basename()
if basename is None:
# If by now, basename is still None, use the current directory name
basename = os.path.basename(py.path.local().strpath) # pylint: disable=no-member
mpatch = monkeypatch()
temproot = py.path.local.get_temproot() # pylint: disable=no-member
# Let's get the full real path to the tempdir
tempdir = temproot.join(basename).realpath()
if tempdir.exists():
# If it exists, it's a stale tempdir. Remove it
log.warning('Removing stale tempdir: %s', tempdir.strpath)
tempdir.remove(rec=True, ignore_errors=True)
# Make sure the tempdir is created
tempdir.ensure(dir=True)
# Store a reference the tempdir for cleanup purposes when ending the test
# session
mpatch.setattr(self.config, '_tempdir', self, raising=False)
# Register the cleanup actions
self.config._cleanup.extend([mpatch.undo, self._clean_up_tempdir])
self.tempdir = tempdir
def pytest_configure(config):
mode = config.getvalue("assertmode")
if config.getvalue("noassert") or config.getvalue("nomagic"):
mode = "plain"
if mode == "rewrite":
try:
import ast # noqa
except ImportError:
mode = "reinterp"
else:
# Both Jython and CPython 2.6.0 have AST bugs that make the
# assertion rewriting hook malfunction.
if (sys.platform.startswith('java')
or sys.version_info[:3] == (2, 6, 0)):
mode = "reinterp"
if mode != "plain":
_load_modules(mode)
m = monkeypatch()
config._cleanup.append(m.undo)
m.setattr(py.builtin.builtins, 'AssertionError',
reinterpret.AssertionError) # noqa
hook = None
if mode == "rewrite":
hook = rewrite.AssertionRewritingHook() # noqa
sys.meta_path.insert(0, hook)
warn_about_missing_assertion(mode)
config._assertstate = AssertionState(config, mode)
config._assertstate.hook = hook
config._assertstate.trace("configured with mode set to %r" % (mode, ))
def setup():
mp = monkeypatch()
mp.setattr(
client,
'_make_authenticated_request',
fake_make_authenticated_request
)
def pytest_configure(config):
warn_about_missing_assertion()
mode = config.getvalue("assertmode")
if config.getvalue("noassert") or config.getvalue("nomagic"):
if mode not in ("off", "default"):
raise pytest.UsageError("assertion options conflict")
mode = "off"
elif mode == "default":
mode = "on"
if mode != "off":
def callbinrepr(op, left, right):
hook_result = config.hook.pytest_assertrepr_compare(
config=config, op=op, left=left, right=right)
for new_expl in hook_result:
if new_expl:
return '\n~'.join(new_expl)
m = monkeypatch()
config._cleanup.append(m.undo)
m.setattr(py.builtin.builtins, 'AssertionError',
reinterpret.AssertionError)
m.setattr(util, '_reprcompare', callbinrepr)
if mode == "on" and rewrite_asserts is None:
mode = "old"
config._assertstate = AssertionState(config, mode)
config._assertstate.trace("configured with mode set to %r" % (mode,))
def pytest_funcarg__mock_ia(request):
"""py.test funcarg to mock openlibrary.core.ia module.
from openlibrary.core import ia
def test_ia(mock_ia):
assert ia.get_meta_xml("foo") == {}
mock_ia.set_meta_xml("foo", {"collection": ["a", "b"]})
assert ia.get_meta_xml("foo") == {"collection": ["a", "b"]}
"""
m = monkeypatch()
request.addfinalizer(m.undo)
metaxml = {}
class IA:
def set_meta_xml(self, itemid, meta):
metaxml[itemid] = meta
def get_meta_xml(self, itemid):
return metaxml.get(itemid, {})
mock_ia = IA()
m.setattr(ia, "get_meta_xml", ia.get_meta_xml)
return mock_ia
def pytest_configure(config):
mode = config.getvalue("assertmode")
if config.getvalue("noassert") or config.getvalue("nomagic"):
mode = "plain"
if mode == "rewrite":
try:
import ast
except ImportError:
mode = "reinterp"
else:
if sys.platform.startswith('java'):
mode = "reinterp"
if mode != "plain":
_load_modules(mode)
m = monkeypatch()
config._cleanup.append(m.undo)
m.setattr(py.builtin.builtins, 'AssertionError',
reinterpret.AssertionError)
hook = None
if mode == "rewrite":
hook = rewrite.AssertionRewritingHook()
sys.meta_path.insert(0, hook)
warn_about_missing_assertion(mode)
config._assertstate = AssertionState(config, mode)
config._assertstate.hook = hook
config._assertstate.trace("configured with mode set to %r" % (mode,))
def _get_test_ccu(self, API):
self._monkeypatch = monkeypatch()
self._monkeypatch.setattr(pmatic.api, 'init', lambda: None)
ccu = pmatic.CCU()
ccu.api = API
return ccu
def getfuncargvalue(self, argname):
""" Retrieve a function argument by name for this test
function invocation. This allows one function argument factory
to call another function argument factory. If there are two
funcarg factories for the same test function argument the first
factory may use ``getfuncargvalue`` to call the second one and
do something additional with the resource.
"""
try:
return self._funcargs[argname]
except KeyError:
pass
if argname not in self._name2factory:
self._name2factory[argname] = self.config.pluginmanager.listattr(
plugins=self._plugins,
attrname=self._argprefix + str(argname)
)
#else: we are called recursively
if not self._name2factory[argname]:
self._raiselookupfailed(argname)
funcargfactory = self._name2factory[argname].pop()
oldarg = self._currentarg
mp = monkeypatch()
mp.setattr(self, '_currentarg', argname)
try:
param = self._pyfuncitem.callspec.getparam(argname)
except (AttributeError, ValueError):
pass
else:
mp.setattr(self, 'param', param, raising=False)
try:
self._funcargs[argname] = res = funcargfactory(request=self)
finally:
mp.undo()
return res
def pytest_funcarg__mock_ia(request):
"""py.test funcarg to mock openlibrary.core.ia module.
from openlibrary.core import ia
def test_ia(mock_ia):
assert ia.get_meta_xml("foo") == {}
mock_ia.set_meta_xml("foo", {"collection": ["a", "b"]})
assert ia.get_meta_xml("foo") == {"collection": ["a", "b"]}
"""
m = monkeypatch()
request.addfinalizer(m.undo)
metaxml = {}
class IA:
def set_meta_xml(self, itemid, meta):
metaxml[itemid] = meta
def get_meta_xml(self, itemid):
return metaxml.get(itemid, {})
mock_ia = IA()
m.setattr(ia, "get_meta_xml", ia.get_meta_xml)
return mock_ia
def _get_test_ccu(self, API):
self._monkeypatch = monkeypatch()
self._monkeypatch.setattr(pmatic.api, 'init', lambda: None)
ccu = pmatic.CCU()
ccu.api = API
return ccu
def pytest_configure(config):
warn_about_missing_assertion()
mode = config.getvalue("assertmode")
if config.getvalue("noassert") or config.getvalue("nomagic"):
if mode not in ("off", "default"):
raise pytest.UsageError("assertion options conflict")
mode = "off"
elif mode == "default":
mode = "on"
if mode != "off":
def callbinrepr(op, left, right):
hook_result = config.hook.pytest_assertrepr_compare(config=config,
op=op,
left=left,
right=right)
for new_expl in hook_result:
if new_expl:
return '\n~'.join(new_expl)
m = monkeypatch()
config._cleanup.append(m.undo)
m.setattr(py.builtin.builtins, 'AssertionError',
reinterpret.AssertionError)
m.setattr(util, '_reprcompare', callbinrepr)
if mode == "on" and rewrite_asserts is None:
mode = "old"
config._assertstate = AssertionState(config, mode)
config._assertstate.trace("configured with mode set to %r" % (mode, ))
def install_pytest_asserts():
try:
import ast # noqa
except ImportError as e:
print('Can not use py.test asserts - import ast failed!')
return
else:
# Both Jython and CPython 2.6.0 have AST bugs that make the
# assertion rewriting hook malfunction.
if (sys.platform.startswith('java')
or sys.version_info[:3] == (2, 6, 0)):
print(
'Can not use py.test asserts - no compatible python interpreter'
)
return
from _pytest.assertion import reinterpret # noqa
from _pytest.assertion import rewrite # noqa
m = monkeypatch()
m.setattr(py.builtin.builtins, 'AssertionError',
reinterpret.AssertionError) # noqa
hook = rewrite.AssertionRewritingHook() # noqa
sys.meta_path.insert(0, hook)
def setup(self):
from _pytest.monkeypatch import monkeypatch
patch = monkeypatch()
patch.setattr('pymongo.MongoClient', mongomock.MongoClient)
from helga_karma.data import KarmaRecord
from helga.db import db
self.KarmaRecord = KarmaRecord
self.db = db
def pytest_configure(config):
"""Create a TempdirFactory and attach it to the config object.
This is to comply with existing plugins which expect the handler to be
available at pytest_configure time, but ideally should be moved entirely
to the tmpdir_factory session fixture.
"""
mp = monkeypatch()
t = TempdirFactory(config)
config._cleanup.extend([mp.undo, t.finish])
mp.setattr(config, '_tmpdirhandler', t, raising=False)
mp.setattr(pytest, 'ensuretemp', t.ensuretemp, raising=False)
def mock_build_commands(request):
from upaas.commands import execute as real_execute
def mock_execute(cmd, *args, **kwargs):
executable = cmd.split(' ')[0]
if executable in ['git', 'chown', 'gem', 'rake', 'bundle']:
return 0, []
else:
return real_execute(cmd, *args, **kwargs)
mpatch = monkeypatch()
mpatch.setattr('upaas.commands.execute', mock_execute)
request.addfinalizer(mpatch.undo)
def mock_build_commands(request):
from upaas.commands import execute as real_execute
def mock_execute(cmd, *args, **kwargs):
executable = cmd.split(" ")[0]
if executable in ["git", "chown", "gem", "rake", "bundle"]:
return 0, []
else:
return real_execute(cmd, *args, **kwargs)
mpatch = monkeypatch()
mpatch.setattr("upaas.commands.execute", mock_execute)
request.addfinalizer(mpatch.undo)
def pytest_configure(self, config):
if not config.getoption('ast_as_python'):
return
mp = monkeypatch()
mp.setattr('_pytest.assertion.rewrite.rewrite_asserts',
make_replacement_rewrite_asserts(self.store))
# written pyc files will bypass our patch, so disable reading them
mp.setattr('_pytest.assertion.rewrite._read_pyc',
lambda source, pyc, trace=None: None)
config._cleanup.append(mp.undo)
def mock_chroot(request):
class MockChroot(object):
def __init__(self, *args, **kwargs):
pass
def __enter__(self):
pass
def __exit__(self, type, value, traceback):
pass
mpatch = monkeypatch()
mpatch.setattr('upaas.chroot.Chroot', MockChroot)
mpatch.setattr('upaas.builder.builder.Chroot', MockChroot)
request.addfinalizer(mpatch.undo)
def test_u2f_valid(self):
m = monkeypatch.monkeypatch()
m.setattr("u2flib_server.u2f.verify_authenticate", lambda *args, **kwargs: True)
m.setattr("u2flib_server.u2f.start_authenticate",
lambda *args, **kwargs: JSONDict({'authenticateRequests': []}))
d = U2FDevice.objects.create(user=self.user, name='test', json_data="{}")
response = self.client.get('/control/login/2fa')
assert 'token' in response.rendered_content
response = self.client.post('/control/login/2fa'.format(d.pk), {
'token': '{"response": "true"}'
})
self.assertEqual(response.status_code, 302)
self.assertIn('/control/', response['Location'])
m.undo()
def pytest_configure(config):
# The _pytesthook attribute on the AssertionError is used by
# py._code._assertionnew to detect this plugin was loaded and in
# turn call the hooks defined here as part of the
# DebugInterpreter.
config._monkeypatch = m = monkeypatch()
if not config.getvalue("noassert") and not config.getvalue("nomagic"):
warn_about_missing_assertion()
def callbinrepr(op, left, right):
hook_result = config.hook.pytest_assertrepr_compare(
config=config, op=op, left=left, right=right)
for new_expl in hook_result:
if new_expl:
return '\n~'.join(new_expl)
m.setattr(py.builtin.builtins,
'AssertionError', py.code._AssertionError)
m.setattr(py.code, '_reprcompare', callbinrepr)
def test_u2f_valid(self):
m = monkeypatch.monkeypatch()
m.setattr("u2flib_server.u2f.verify_authenticate",
lambda *args, **kwargs: True)
m.setattr(
"u2flib_server.u2f.start_authenticate",
lambda *args, **kwargs: JSONDict({'authenticateRequests': []}))
d = U2FDevice.objects.create(user=self.user,
name='test',
json_data="{}")
response = self.client.get('/control/login/2fa')
assert 'token' in response.rendered_content
response = self.client.post('/control/login/2fa'.format(d.pk),
{'token': '{"response": "true"}'})
self.assertEqual(response.status_code, 302)
self.assertIn('/control/', response['Location'])
m.undo()
def API(self, request):
self._monkeypatch = monkeypatch()
if not is_testing_with_real_ccu():
# First hook into urlopen to fake the HTTP responses
self._monkeypatch.setattr(pmatic.api, 'urlopen', fake_urlopen)
else:
# When executed with real ccu we wrap urlopen for enabling recording
self._monkeypatch.setattr(pmatic.api, 'urlopen', wrap_urlopen)
API = pmatic.api.RemoteAPI(
address="http://192.168.1.26",
credentials=("Admin", "EPIC-SECRET-PW"),
connect_timeout=5,
#log_level=pmatic.DEBUG,
)
request.addfinalizer(API.close)
return API
def API(self, request):
self._monkeypatch = monkeypatch()
if not is_testing_with_real_ccu():
# First hook into urlopen to fake the HTTP responses
self._monkeypatch.setattr(pmatic.api, 'urlopen', fake_urlopen)
else:
# When executed with real ccu we wrap urlopen for enabling recording
self._monkeypatch.setattr(pmatic.api, 'urlopen', wrap_urlopen)
API = pmatic.api.RemoteAPI(
address="http://192.168.1.26",
credentials=("Admin", "EPIC-SECRET-PW"),
connect_timeout=5,
#log_level=pmatic.DEBUG,
)
request.addfinalizer(API.close)
return API
def test_confirm_u2f_success(self):
with mocker_context() as mocker:
mocker.patch('django.http.request.HttpRequest.is_secure')
self.client.post('/control/settings/2fa/add', {
'devicetype': 'u2f',
'name': 'Foo'
}, follow=True)
m = monkeypatch.monkeypatch()
m.setattr("u2flib_server.u2f.complete_register", lambda *args, **kwargs: (JSONDict({}), None))
d = U2FDevice.objects.first()
r = self.client.post('/control/settings/2fa/u2f/{}/confirm'.format(d.pk), {
'token': 'FOO'
}, follow=True)
d.refresh_from_db()
assert d.confirmed
assert 'alert-success' in r.rendered_content
m.undo()
def pytest_funcarg__mock_memcache(request):
"""This patches all the existing memcache connections to use mock memcache instance.
"""
m = monkeypatch()
request.addfinalizer(m.undo)
mock_memcache = Client()
def proxy(name):
method = getattr(mock_memcache, name)
def f(self, *a, **kw):
return method(*a, **kw)
return f
m.setattr(memcache.Client, "get", proxy("get"))
m.setattr(memcache.Client, "set", proxy("set"))
m.setattr(memcache.Client, "add", proxy("add"))
return mock_memcache
def pytest_configure(config):
# The _pytesthook attribute on the AssertionError is used by
# py._code._assertionnew to detect this plugin was loaded and in
# turn call the hooks defined here as part of the
# DebugInterpreter.
config._monkeypatch = m = monkeypatch()
if not config.getvalue("noassert") and not config.getvalue("nomagic"):
warn_about_missing_assertion()
def callbinrepr(op, left, right):
hook_result = config.hook.pytest_assertrepr_compare(config=config,
op=op,
left=left,
right=right)
for new_expl in hook_result:
if new_expl:
return '\n~'.join(new_expl)
m.setattr(py.builtin.builtins, 'AssertionError',
py.code._AssertionError)
m.setattr(py.code, '_reprcompare', callbinrepr)
def pytest_funcarg__mock_memcache(request):
"""This patches all the existing memcache connections to use mock memcache instance.
"""
m = monkeypatch()
request.addfinalizer(m.undo)
mock_memcache = Client()
def proxy(name):
method = getattr(mock_memcache, name)
def f(self, *a, **kw):
return method(*a, **kw)
return f
m.setattr(memcache.Client, "get", proxy("get"))
m.setattr(memcache.Client, "set", proxy("set"))
m.setattr(memcache.Client, "add", proxy("add"))
return mock_memcache
def test_confirm_u2f_success(self):
with mocker_context() as mocker:
mocker.patch('django.http.request.HttpRequest.is_secure')
self.client.post('/control/settings/2fa/add', {
'devicetype': 'u2f',
'name': 'Foo'
},
follow=True)
m = monkeypatch.monkeypatch()
m.setattr("u2flib_server.u2f.complete_register",
lambda *args, **kwargs: (JSONDict({}), None))
d = U2FDevice.objects.first()
r = self.client.post('/control/settings/2fa/u2f/{}/confirm'.format(
d.pk), {'token': 'FOO'},
follow=True)
d.refresh_from_db()
assert d.confirmed
assert 'alert-success' in r.rendered_content
m.undo()
def install_pytest_asserts():
try:
import ast # noqa
except ImportError as e:
print('Can not use py.test asserts - import ast failed!')
return
else:
# Both Jython and CPython 2.6.0 have AST bugs that make the
# assertion rewriting hook malfunction.
if (sys.platform.startswith('java') or
sys.version_info[:3] == (2, 6, 0)):
print('Can not use py.test asserts - no compatible python interpreter')
return
from _pytest.assertion import reinterpret # noqa
from _pytest.assertion import rewrite # noqa
m = monkeypatch()
m.setattr(py.builtin.builtins, 'AssertionError',
reinterpret.AssertionError) # noqa
hook = rewrite.AssertionRewritingHook() # noqa
sys.meta_path.insert(0, hook)
def __init__(self, fake_call_impl_any):
self.fake_call_impl_any = fake_call_impl_any
self.monkey = monkeypatch()
from _pytest.monkeypatch import monkeypatch
from selvpcclient.httpclient import HTTPClient
monkeypatch().setenv("SEL_URL", "http://api")
client = HTTPClient(base_url="http://api/v2", headers={})
def __init__(self, tty=True):
self.monkey = monkeypatch()
self.tty = tty
self.output = []
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright 2014 Evernote Corporation
#
# This file is part of Pootle.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
"""Monkeypatching fixtures."""
# HACKISH: monkeypatching decorator here, should be cleaner to do it in a
# fixture, but pytest's `monkeypatch` decorator is function-scoped, and by
# the time it's run the decorators have already been applied to the
# functions, therefore the patching has no effect
from _pytest.monkeypatch import monkeypatch
mp = monkeypatch()
mp.setattr('pootle_misc.util.cached_property', property)
def setUp(self):
self.m = monkeypatch()
def monkeypatch_session(request):
mp = monkeypatch(request)
request.addfinalizer(mp.undo)
return mp
def pytest_configure(config):
config._mp = mp = monkeypatch()
t = TempdirHandler(config)
mp.setattr(config, '_tmpdirhandler', t, raising=False)
mp.setattr(pytest, 'ensuretemp', t.ensuretemp, raising=False)
def pytest_configure(config):
mp = monkeypatch()
t = TempdirHandler(config)
config._cleanup.extend([mp.undo, t.finish])
mp.setattr(config, '_tmpdirhandler', t, raising=False)
mp.setattr(pytest, 'ensuretemp', t.ensuretemp, raising=False)
def pytest_configure(config):
mp = monkeypatch()
t = TempdirHandler(config)
config._cleanup.extend([mp.undo, t.finish])
mp.setattr(config, '_tmpdirhandler', t, raising=False)
mp.setattr(pytest, 'ensuretemp', t.ensuretemp, raising=False)
def __init__(self, tty=True):
self.monkey = monkeypatch()
self.tty = tty
self.output = []
import json
import mock
from selvpcclient.client import Client
from selvpcclient.shell import CLI
from _pytest.monkeypatch import monkeypatch
monkeypatch().setenv("SEL_URL", "http://selvpcapi")
monkeypatch().setenv("SEL_TOKEN", "5ba50055-ff2e-4145-a8cf-f03e9fbd5ee6")
def prepare_to_run_command(cmd):
pass
class FakeStdout(object):
def __init__(self):
self.content = []
def write(self, text):
self.content.append(text)
def make_string(self):
pass
def run_cmd(args, client, json_output=False, print_output=True):
if json_output:
args.extend(['-f', 'json'])
stdout = FakeStdout()
def __init__(self, fake_call_impl_any):
self.fake_call_impl_any = fake_call_impl_any
self.monkey = monkeypatch()
def pytest_configure(config):
if pytest.__version__ != "2.7.2":
from _pytest.monkeypatch import monkeypatch
import reinterpret
m = next(monkeypatch())
m.setattr(py.builtin.builtins, 'AssertionError',
reinterpret.AssertionError) # noqa
config.option.continue_on_collection_errors = True
config.from_ya_test = "YA_TEST_RUNNER" in os.environ
config.test_logs = collections.defaultdict(dict)
config.test_metrics = {}
context = {
"project_path": config.option.project_path,
"test_stderr": config.option.test_stderr,
"test_debug": config.option.test_debug,
"build_type": config.option.build_type,
"test_traceback": config.option.tbstyle,
"flags": config.option.flags,
"sanitize": config.option.sanitize,
}
config.ya = Ya(
config.option.mode,
config.option.source_root,
config.option.build_root,
config.option.dep_roots,
config.option.output_dir,
config.option.test_params,
context,
config.option.python_path,
config.option.valgrind_path,
config.option.gdb_path,
config.option.data_root,
)
config.option.test_log_level = {
"critical": logging.CRITICAL,
"error": logging.ERROR,
"warning": logging.WARN,
"info": logging.INFO,
"debug": logging.DEBUG,
}[config.option.test_log_level]
if not config.option.collectonly:
setup_logging(os.path.join(config.ya.output_dir, "run.log"),
config.option.test_log_level)
config.current_item_nodeid = None
config.current_test_name = None
config.test_cores_count = 0
config.collect_cores = config.option.collect_cores
config.sanitizer_extra_checks = config.option.sanitizer_extra_checks
if config.sanitizer_extra_checks:
for envvar in ['LSAN_OPTIONS', 'ASAN_OPTIONS']:
if envvar in os.environ:
os.environ.pop(envvar)
if envvar + '_ORIGINAL' in os.environ:
os.environ[envvar] = os.environ[envvar + '_ORIGINAL']
config.coverage = None
cov_prefix = os.environ.get('PYTHON_COVERAGE_PREFIX')
if cov_prefix:
config.coverage_data_dir = os.path.dirname(cov_prefix)
import coverage
cov = coverage.Coverage(
data_file=cov_prefix,
concurrency=['multiprocessing', 'thread'],
auto_data=True,
# debug=['pid', 'trace', 'sys', 'config'],
)
config.coverage = cov
config.coverage.start()
logging.info("Coverage will be collected during testing. pid: %d",
os.getpid())
if config.option.root_dir:
config.rootdir = config.invocation_dir = py.path.local(
config.option.root_dir)
# Arcadia paths from the test DEPENDS section of CMakeLists.txt
sys.path.insert(
0, os.path.join(config.option.source_root, config.option.project_path))
sys.path.extend([
os.path.join(config.option.source_root, d)
for d in config.option.dep_roots
])
sys.path.extend([
os.path.join(config.option.build_root, d)
for d in config.option.dep_roots
])
# Build root is required for correct import of protobufs, because imports are related to the root
# (like import devtools.dummy_arcadia.protos.lib.my_proto_pb2)
sys.path.append(config.option.build_root)
os.environ["PYTHONPATH"] = os.pathsep.join(
os.environ.get("PYTHONPATH", "").split(os.pathsep) + sys.path)
if not config.option.collectonly:
if config.option.ya_trace_path:
config.ya_trace_reporter = TraceReportGenerator(
config.option.ya_trace_path)
else:
config.ya_trace_reporter = DryTraceReportGenerator(
config.option.ya_trace_path)
config.ya_version = config.option.ya_version
sys.meta_path.append(
CustomImporter([config.option.build_root] + [
os.path.join(config.option.build_root, dep)
for dep in config.option.dep_roots
]))
if config.option.pdb_on_sigusr1:
configure_pdb_on_demand()
def pytest_configure(config):
config._mp = mp = monkeypatch()
t = TempdirHandler(config)
mp.setattr(config, '_tmpdirhandler', t, raising=False)
mp.setattr(pytest, 'ensuretemp', t.ensuretemp, raising=False)
def setup():
os.environ.clear()
mp = monkeypatch()
mp.setattr(register, 'put_host', fake_put_host)
mp.setattr(register, '_get_local_ipv4', fake_get_local_ipv4)
def setup():
mp = monkeypatch()
mp.setattr('os.getlogin', lambda: 'pytest')
mp.setattr('socket.gethostname', lambda: 'bar.desktop.local')
