Exemplo n.º 1
0
 def __new__(cls, clsname, bases, dct):
     klass = type.__new__(cls, clsname, bases, dct)
     for app_name in set(settings.INSTALLED_APPS):
         name = app_name.split('.')[-1]
         setattr(klass, name, pytest.fixture(scope='session')(django_app(app_name)))
     for model in apps.get_models():
         name = model._meta.object_name
         setattr(klass, name, pytest.fixture(scope='session')(django_model(model)))
     return klass
Exemplo n.º 2
0
    def decorator(func):
        step_func = func
        if step_type == GIVEN:
            if not hasattr(func, '_pytestfixturefunction'):
                # avoid overfixturing of a fixture
                func = pytest.fixture(func)
            step_func = lambda request: request.getfuncargvalue(func.func_name)

        step_func.__name__ = step_name
        setattr(get_caller_module(), step_name, pytest.fixture(lambda: step_func))
        return func
Exemplo n.º 3
0
        def decorate(fn):
            name = fn.__name__
            self._factories[name] = fn
            # conn, teardown = self.connection_for(name)

            def wrapper(*args, **kw):
                # This check might be unnecessary
                assert self._current_connection == name
                return fn(*args, **kw)

            wrapper.__wrapped__ = fn
            pytest.fixture(scope="session")(wrapper)
            return wrapper
Exemplo n.º 4
0
    def simple_fixture(name, params, fmt=None):
        """Helper to create a pytest fixture using only name and params.

        Parameters
        ----------
        name : str
            Name of the parameters used for the ``ids`` argument
            to `pytest.fixture`.
        params : sequence
            Values to be taken as parameters in the fixture. They are
            used as ``params`` argument to `pytest.fixture`.
        fmt : str, optional
            Use this format string for the generation of the ``ids``.
            For each value, the id string is generated as::

                fmt.format(name=name, value=value)

            hence the format string must use ``{name}`` and ``{value}``.

            Default: ``" {name} = '{value}' "`` for string parameters,
            otherwise ``" {name} = {value} "``
        """
        if fmt is None:
            try:
                params[0] + ''
            except TypeError:
                # Not a string type
                fmt = " {name} = {value} "
            else:
                # String type
                fmt = " {name} = '{value}' "

        ids = [fmt.format(name=name, value=value) for value in params]
        wrapper = pytest.fixture(scope='module', ids=ids, params=params)
        return wrapper(lambda request: request.param)
Exemplo n.º 5
0
    def decorator(func):
        step_func = func

        if step_type == GIVEN:
            if not hasattr(func, "_pytestfixturefunction"):
                # Avoid multiple wrapping of a fixture
                func = pytest.fixture(func)
            step_func = lambda request: request.getfuncargvalue(func.__name__)
            step_func.__doc__ = func.__doc__
            step_func.fixture = func.__name__

        step_func.__name__ = force_encode(step_name)
        step_func.step_type = step_type
        step_func.converters = converters

        @pytest.fixture
        def lazy_step_func():
            return step_func

        # Preserve the docstring
        lazy_step_func.__doc__ = func.__doc__

        if pattern:
            lazy_step_func.pattern = pattern
        if converters:
            lazy_step_func.converters = converters

        contribute_to_module(get_caller_module(), step_name, lazy_step_func)
        return func
Exemplo n.º 6
0
def given(name, fixture=None, converters=None, scope='function', target_fixture=None):
    """Given step decorator.

    :param name: Given step name.
    :param fixture: Optional name of the fixture to reuse.
    :param converters: Optional `dict` of the argument or parameter converters in form
                       {<param_name>: <converter function>}.
    :scope: Optional fixture scope
    :param target_fixture: Target fixture name to replace by steps definition function
    :raises: StepError in case of wrong configuration.
    :note: Can't be used as a decorator when the fixture is specified.
    """
    if fixture is not None:
        module = get_caller_module()

        def step_func(request):
            return request.getfuncargvalue(fixture)

        step_func.step_type = GIVEN
        step_func.converters = converters
        step_func.__name__ = name
        step_func.fixture = fixture
        func = pytest.fixture(scope=scope)(lambda: step_func)
        func.__doc__ = 'Alias for the "{0}" fixture.'.format(fixture)
        _, name = parse_line(name)
        contribute_to_module(module, get_step_fixture_name(name, GIVEN), func)
        return _not_a_fixture_decorator

    return _step_decorator(GIVEN, name, converters=converters, scope=scope, target_fixture=target_fixture)
Exemplo n.º 7
0
def given(name, fixture=None, converters=None):
    """Given step decorator.

    :param name: Given step name.
    :param fixture: Optional name of the fixture to reuse.
    :param converters: Optional `dict` of the argument or parameter converters in form
    {<param_name>: <converter function>}.

    :raises: StepError in case of wrong configuration.
    :note: Can't be used as a decorator when the fixture is specified.

    """

    if fixture is not None:
        module = get_caller_module()
        step_func = lambda request: request.getfuncargvalue(fixture)
        step_func.step_type = GIVEN
        step_func.converters = converters
        step_func.__name__ = name
        step_func.fixture = fixture
        func = pytest.fixture(lambda: step_func)
        func.__doc__ = 'Alias for the "{0}" fixture.'.format(fixture)
        contribute_to_module(module, remove_prefix(name), func)
        return _not_a_fixture_decorator

    return _step_decorator(GIVEN, name, converters=converters)
Exemplo n.º 8
0
    def decorator(func):

        step_func = func

        if step_type == GIVEN:
            if not hasattr(func, '_pytestfixturefunction'):
                # Avoid multiple wrapping a fixture
                func = pytest.fixture(func)
            step_func = lambda request: request.getfuncargvalue(func.__name__)
            step_func.__doc__ = func.__doc__

        step_func.__name__ = step_name

        @pytest.fixture
        def lazy_step_func():
            return step_func

        # Preserve a docstring
        lazy_step_func.__doc__ = func.__doc__

        contribute_to_module(
            get_caller_module(),
            step_name,
            lazy_step_func,
        )
        return func
Exemplo n.º 9
0
    def _make_fixture(cls, name):
        factory = getattr(cls, name + '_factory')

        def fixture(self):
            return factory.create()

        fixture.__name__ = name
        return pytest.fixture(fixture)
Exemplo n.º 10
0
def _get_role_fixture(role_name):
    def fixture(testuser_id, webapp_without_login):
        with webapp_without_login.app.app_context():
            user = models.User.query.get(testuser_id)
            user.roles.append(models.Role.query.filter_by(name=role_name).one())
            models.db.session.commit()

    fixture.__name__ = "{}_role".format(role_name)
    return pytest.fixture(fixture)
Exemplo n.º 11
0
def calc_motor_fixture(name):
    def get_motor(beacon):
        m = beacon.get(name)
        m.no_offset = False
        yield m
        m.stop()
        m.wait_move()
    get_motor.__name__ = name
    return pytest.fixture(get_motor)
Exemplo n.º 12
0
def make_uri_fixture(name):
    """
    Create a pytest fixture named NAME that resolves
    to a URI object '<ex://NAME>'.
    """
    # noinspection PyShadowingNames
    def func(conn):
        return conn.createURI('ex://' + name)
    func.__name__ = name
    return pytest.fixture(func, name=name)
Exemplo n.º 13
0
        def make_fixture(arg):
            args_attr = 'base_args__' + arg
            kwargs_attr = 'base_kwargs__' + arg

            def fixture(self, cls):
                args = getattr(self, args_attr)
                kwargs = getattr(self, kwargs_attr)
                return cls(*args, **kwargs)

            fixture.__name__ = arg
            return pytest.fixture(fixture)
Exemplo n.º 14
0
def instance_fixture(func):
    """
    Mark function as an instance fixture.

    It marks function as a fixture and also applies pytest.mark.instance_fixture
    """

    func = pytest.fixture(func)
    func = pytest.mark.instance_fixture(func)
    func.__is_instance_fixture = True
    return func
Exemplo n.º 15
0
def fixture(scope="function", params=None, autouse=False, ids=None, name=None):
    """
    When running under pytest, this is the same as the pytest.fixture decorator.
    See https://docs.pytest.org/en/latest/reference.html#pytest-fixture
    """
    if _use_native_pytest:
        # XXX sorting of fixtures based on scope does not work, see
        # https://github.com/pytest-dev/pytest/issues/4143#issuecomment-431794076
        # When ran under pytest, use native functionality.
        return pytest.fixture(scope, params, autouse, ids, name)
    init_fallback_fixtures_once()
    return _fallback.fixture(scope, params, autouse, ids, name)
Exemplo n.º 16
0
def setup_pytest_browser_fixture(BrowserClass):
    def browser(live_server, settings):
        # also require the live_server fixture from pytest-django
        # django runserver doesnt support https.
        # todo: can just replace live_server with own fixture that
        # runs the stunnel script instead
        # todo: or can do local setting imports and have a testing one?
        settings.SESSION_COOKIE_SECURE = False
        settings.CSRF_COOKIE_SECURE = False
        _browser = BrowserClass(host_address=live_server.url)
        yield _browser
        # use quit instead of close to release all resources
        _browser.quit()
    return pytest.fixture(browser)
Exemplo n.º 17
0
def motor_fixture(name):
    def get_motor(beacon):
        m = beacon.get(name)
        yield m
        m.stop()
        m.wait_move()
        m.apply_config()
        m.controller.set_hw_limits(m, None, None)
        m.dial(0)
        m.position(0)
        for hook in m.motion_hooks:
            hook.nb_pre_move = 0
            hook.nb_post_move = 0
    get_motor.__name__ = name
    return pytest.fixture(get_motor)
Exemplo n.º 18
0
def pytest_configure(config):
    # Enable stdout and stderr analysis, unless output capture is disabled
    if config.getoption('capture') != 'no':
        global check_test_output
        check_test_output = pytest.fixture(autouse=True)(check_test_output)

    # If we are running from the source directory, make sure that we load
    # modules from here
    basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
    if not config.getoption('installed'):
        llfuse_path = os.path.join(basedir, 'src')
        if (os.path.exists(os.path.join(basedir, 'setup.py')) and
            os.path.exists(os.path.join(basedir, 'src', 'llfuse.pyx'))):
            sys.path.insert(0, llfuse_path)

        # Make sure that called processes use the same path
        pp = os.environ.get('PYTHONPATH', None)
        if pp:
            pp = '%s:%s' % (llfuse_path, pp)
        else:
            pp = llfuse_path
        os.environ['PYTHONPATH'] = pp

    try:
        import faulthandler
    except ImportError:
        pass
    else:
        faulthandler.enable()

    # When running from VCS repo, enable all warnings
    if os.path.exists(os.path.join(basedir, 'MANIFEST.in')):
        import warnings
        warnings.resetwarnings()
        warnings.simplefilter('error')

    logdebug = config.getoption('logdebug')
    if logdebug:
        root_logger = logging.getLogger()
        formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s '
                                      '%(funcName)s: %(message)s',
                                      datefmt="%H:%M:%S")
        handler = logging.StreamHandler(sys.stdout)
        handler.setLevel(logging.DEBUG)
        handler.setFormatter(formatter)
        root_logger.addHandler(handler)
        root_logger.setLevel(logging.DEBUG)
Exemplo n.º 19
0
def given(name, fixture=None):
    """Given step decorator.

    :param name: Given step name.
    :param fixture: Optional name of the fixture to reuse.

    :raises: StepError in case of wrong configuration.
    :note: Can't be used as a decorator when the fixture is specified.
    """
    name = remove_prefix(name)
    if fixture is not None:
        module = get_caller_module()
        func = getattr(module, fixture, lambda request: request.getfuncargvalue(fixture))
        setattr(module, name, pytest.fixture(lambda: func))
        return _not_a_fixture_decorator

    return _step_decorator(GIVEN, name)
Exemplo n.º 20
0
def model_fixture(func):
    """
    Marks function that returns a Model instance as a fixture

    Consider the example::

        @model_fixture
        def foo():
            return ...

    This is the same as::

        @pytest.fixture
        @pytest.mark.db
        def foo():
            return ...
    """
    return pytest.fixture(pytest.mark.db(func))
Exemplo n.º 21
0
def fixture(**kwargs):
    pytest_fn = pytest.fixture(**kwargs)
    def _dec(fn):
        def _fn(request, *args, **kwargs):
            if not hasattr(request, '__zk_finalizers'):
                request.addfinalizer(mock_zookeeper.dump)
                request.addfinalizer(mock_zookeeper.reset)
                setattr(request, '__zk_finalizers', True)
            mangled_name = "%s__%s__%s" % (fn.__name__, str(args), str(kwargs))
            if hasattr(request, mangled_name):
                val = getattr(request, mangled_name)
            else:
                val = fn(request, *args, **kwargs)
                setattr(request, mangled_name, val)
            return val
        _fn.__name__ = fn.__name__
        _fn.__doc__ = fn.__doc__
        return pytest_fn(_fn)
    return _dec
Exemplo n.º 22
0
def make_fixture(name, module, func, args=None, **kwargs):
    """Make fixture function and inject arguments.

    :param name: Fixture name.
    :param module: Python module to contribute the fixture into.
    :param func: Fixture implementation function.
    :param args: Argument names.
    """
    args = [] if args is None else list(args)
    if "request" not in args:
        args.insert(0, "request")
    deps = ", ".join(args)
    context = dict(_fixture_impl=func, kwargs=kwargs)
    context.update(kwargs)
    exec(FIXTURE_FUNC_FORMAT.format(name=name, deps=deps), context)
    fixture_func = context[name]
    fixture_func.__module__ = module
    fixture = pytest.fixture(fixture_func)
    setattr(module, name, fixture)
    return fixture
Exemplo n.º 23
0
def pytest_pycollect_makemodule(path, parent):
    """
    py.test hook called when a new test module is generated.

    If your test module contains a class named "Fixtures" with
    :class:`Fixture` instances as (class) attributes, this will set up "lazy"
    fixtures to use within the test module.
    """
    mod = path.pyimport()
    fixtures = getattr(mod, 'Fixtures', None)
    if not fixtures is None:
        fixtures = [item for item in fixtures.__dict__.items()
                    if (callable(item[1])
                        and not item[0].startswith('_'))]
        for (fx_name, func) in fixtures:
            if getfixturemarker(func) is None:
                fxt = pytest.fixture(scope='function')(func)
            else:
                fxt = func
            setattr(mod, fx_name, fxt)
    return pytest.Module(path, parent)
Exemplo n.º 24
0
def given(name, fixture=None):
    """Given step decorator.

    :param name: Given step name.
    :param fixture: Optional name of the fixture to reuse.

    :raises: StepError in case of wrong configuration.
    :note: Can't be used as a decorator when the fixture is specified.
    """
    if fixture is not None:
        frame = inspect.stack()[1]
        module = inspect.getmodule(frame[0])
        func = getattr(module, fixture, None)
        if func is None:
            func = pytest.fixture(lambda request: request.getfuncargvalue(fixture))
            setattr(module, fixture, func)

        _decorate_step(func, GIVEN, name)
        return _not_a_fixture_decorator

    return _step_decorator(GIVEN, name)
Exemplo n.º 25
0
    def decorator(func):
        step_func = func
        parser_instance = get_parser(step_name)
        parsed_step_name = parser_instance.name

        if step_type == GIVEN:
            if not hasattr(func, "_pytestfixturefunction"):
                # Avoid multiple wrapping of a fixture
                func = pytest.fixture(scope=scope)(func)

            def step_func(request):
                result = request.getfuncargvalue(func.__name__)
                if target_fixture:
                    inject_fixture(request, target_fixture, result)
                return result

            step_func.__doc__ = func.__doc__
            step_func.fixture = func.__name__

        step_func.__name__ = force_encode(parsed_step_name)

        @pytest.fixture(scope=scope)
        def lazy_step_func():
            return step_func

        step_func.step_type = step_type

        lazy_step_func = contribute_to_module(
            get_caller_module(), get_step_fixture_name(parsed_step_name, step_type), lazy_step_func)

        lazy_step_func.step_type = step_type

        # Preserve the docstring
        lazy_step_func.__doc__ = func.__doc__

        step_func.parser = lazy_step_func.parser = parser_instance
        if converters:
            step_func.converters = lazy_step_func.converters = converters

        return func
Exemplo n.º 26
0
    def decorator_factory(func):
        fixture_kwargs = {}
        if 'scope' in kwargs:
            fixture_kwargs['scope'] = kwargs.pop('scope')

        if 'autouse' in kwargs:
            fixture_kwargs['autouse'] = kwargs.pop('autouse')

        if 'params' in kwargs:
            fixture_kwargs['params'] = list(kwargs.pop('params'))

        if 'ids' in kwargs:
            fixture_kwargs['ids'] = list(kwargs.pop('ids'))

        if kwargs:
            fixture_kwargs.setdefault('params', []).extend(kwargs.values())
            fixture_kwargs.setdefault('ids', []).extend(kwargs.keys())

        if args:
            fixture_kwargs.setdefault('params', []).extend(args)

        return pytest.fixture(**fixture_kwargs)(func)
Exemplo n.º 27
0
difficult to run in other contexts.
"""

from hil.test_common import *
from hil.dev_support import have_dry_run
from hil import config, server
import pytest


@pytest.fixture
def configure():
    config_testsuite()
    config.load_extensions()


fail_on_log_warnings = pytest.fixture(autouse=True)(fail_on_log_warnings)
fresh_database = pytest.fixture(fresh_database)


@pytest.fixture
def server_init():
    server.register_drivers()
    server.validate_state()


with_request_context = pytest.yield_fixture(with_request_context)

headnode_cleanup = pytest.fixture(headnode_cleanup)
pytestmark = pytest.mark.usefixtures('configure', 'server_init',
                                     'fresh_database', 'with_request_context',
                                     'headnode_cleanup')
Exemplo n.º 28
0
# you may not use this file except in compliance with the
# License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an "AS
# IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
# express or implied.  See the License for the specific language
# governing permissions and limitations under the License.

from hil.dev_support import no_dry_run
import pytest
from hil.test_common import *

fail_on_log_warnings = pytest.fixture(autouse=True)(fail_on_log_warnings)

# We test two ways of using the decorator: applying it to a freestanding
# function, and applying it to an instance method.


def _function():
    @no_dry_run
    def func():
        assert False

    func()


def _method():
    class Cls:
Exemplo n.º 29
0
def _generate_fixture(container):
    def _fixture():
        yield container

    _fixture.__doc__ = f"Provides access to Brownie ContractContainer object '{container._name}'"
    return pytest.fixture(scope="session")(_fixture)
Exemplo n.º 30
0
@when("writing to pwscf.in without specifying a structure")
def writing_no_structure(empty_pwscf, tmpdir):
    empty_pwscf.write(tmpdir.join("pwscf.in"))


@then("the file pwscf.in appears and can be read")
def read_pwscf(tmpdir):
    from pylada.espresso import Pwscf
    assert tmpdir.join("pwscf.in").check(file=True)
    result = Pwscf()
    result.read(tmpdir.join("pwscf.in"))
    return result


pwscf_out = pytest.fixture(read_pwscf)


@then("pwscf.electrons.whawha is equal to 1.5")
def check_float_attribute_exists(pwscf_out):
    from numpy import abs
    assert hasattr(getattr(pwscf_out, "electrons"), "whawha")
    actual = float(getattr(getattr(pwscf_out, "electrons"), "whawha"))
    assert abs(actual - 1.5) < 1e-12


@then("wavefunction cutoff is equal to 14.0 Ry")
def check_ecutwfc(pwscf_out):
    import quantities
    from numpy import allclose
    assert pwscf_out.system.ecutwfc.units == quantities.Ry
Exemplo n.º 31
0
# FIXME: Move this to dolfin for user access?
def reconstruct_refined_form(form, functions, mesh):
    function_mapping = {}
    for u in functions:
        w = Function(u.leaf_node().function_space())
        w.assign(u.leaf_node())
        function_mapping[u] = w
    domain = mesh.leaf_node().ufl_domain()
    newform = replace_integral_domains(replace(form, function_mapping), domain)
    return newform, function_mapping


# This must be scope function, because the tests will modify some of the objects,
# including the mesh which gets its hierarchial adapted submeshes attached.
fixt = pytest.fixture(scope="function")

@fixt
def mesh():
    return UnitSquareMesh(8, 8)

@fixt
def V(mesh):
    return FunctionSpace(mesh, "Lagrange", 1)

@fixt
def u(V):
    return Function(V)

@fixt
def a(V):
Exemplo n.º 32
0
                     c=count - x,
                     d=99 - y)
            b.author = author
            if y % 4 != 0:
                b.prequel = abooks[(2 * y + 1) % len(abooks)]
            abooks.append(b)
            data.append(b)

    with temporary_database(request.param) as dburl:
        with S(dburl) as s:
            Base.metadata.create_all(s.connection())
            s.add_all(data)
        yield dburl


dburl = pytest.fixture(params=['postgresql', 'mysql'])(_dburl)
pg_only_dburl = pytest.fixture(params=['postgresql'])(_dburl)


@pytest.fixture(params=['postgresql', 'mysql'])
def joined_inheritance_dburl(request):
    with temporary_database(request.param) as dburl:
        with S(dburl) as s:
            JoinedInheritanceBase.metadata.create_all(s.connection())
            s.add_all([
                Mammal(name='Human',
                       vertebra_count=33,
                       leg_count=2,
                       nipple_count=2),
                Mammal(name='Dog',
                       vertebra_count=36,
Exemplo n.º 33
0
import pytest

from . import VirtualEnv


def _virtualenv_fixture(cloaked):
    def fn(workspace):
        venv = VirtualEnv(workspace, cloaked=cloaked)
        if cloaked:
            venv.freeze()
        yield venv
        if cloaked:
            venv.thaw()
        # Workaround workspace not cleaning itself as it should...
        venv.workspace.delete = True
        venv.workspace.teardown()

    return fn


virtualenv = pytest.fixture(_virtualenv_fixture(True))
naked_virtualenv = pytest.fixture(_virtualenv_fixture(False))
Exemplo n.º 34
0
from hil.test_common import config_testsuite, fresh_database, \
    fail_on_log_warnings, server_init
from hil import api, config, rest

import json
import pytest


@pytest.fixture
def configure():
    """Configure HIL"""
    config_testsuite()
    config.load_extensions()


fail_on_log_warnings = pytest.fixture(autouse=True)(fail_on_log_warnings)
fresh_database = pytest.fixture(fresh_database)
server_init = pytest.fixture(server_init)


pytestmark = pytest.mark.usefixtures('configure',
                                     'fresh_database',
                                     'server_init')


def test_many_http_queries():
    """Put a few objects in the db, then bombard the api with queries.

    This is intended to shake out problems like the resource leak discussed
    in issue #454.
    """
Exemplo n.º 35
0
                                     autospec=autospec,
                                     new_callable=new_callable,
                                     **kwargs)


def _mocker(pytestconfig: Any) -> Generator[MockerFixture, None, None]:
    """
    Return an object that has the same interface to the `mock` module, but
    takes care of automatically undoing all patches after each test method.
    """
    result = MockerFixture(pytestconfig)
    yield result
    result.stopall()


mocker = pytest.fixture()(_mocker)  # default scope is function
class_mocker = pytest.fixture(scope="class")(_mocker)
module_mocker = pytest.fixture(scope="module")(_mocker)
package_mocker = pytest.fixture(scope="package")(_mocker)
session_mocker = pytest.fixture(scope="session")(_mocker)

_mock_module_patches = []  # type: List[Any]
_mock_module_originals = {}  # type: Dict[str, Any]


def assert_wrapper(__wrapped_mock_method__: Callable[..., Any], *args: Any,
                   **kwargs: Any) -> None:
    __tracebackhide__ = True
    try:
        __wrapped_mock_method__(*args, **kwargs)
        return
Exemplo n.º 36
0
 def fixture_wrapper(func):
     for t in types:
         registered_types.setdefault(t, []).append(func.__name__)
     return pytest.fixture(**kwargs)(func)
Exemplo n.º 37
0
def make_G():
    # Set up a test problem
    G = np.eye(n)
    normal = np.random.normal
    norm = np.linalg.norm

    for jj in range(5):
        gg = normal(size=n)
        hh = gg * gg.T
        G += (hh + hh.T) * 0.5
        G += normal(size=n) * normal(size=n)
    return G


G = pytest.fixture(make_G)


def make_b():
    return np.random.normal(size=n)


b = pytest.fixture(make_b)

tol = 1e-10
show = False
maxit = None


@pytest.mark.parametrize('xp', [
    pytest.param(cupy,
Exemplo n.º 38
0
        "hil.ext.obm.ipmi = ",
        "[devel]",
        "dry_run = True",
        "[headnode]",
        "base_imgs = base-headnode, img1, img2, img3, img4",
        "[database]",
        "uri = sqlite:///" + tmpdir + "/hil.db",
    ])
    with open(tmpdir + '/hil.cfg', 'w') as f:
        f.write(cfg)
    config.load(tmpdir + '/hil.cfg')
    config.configure_logging()
    config.load_extensions()


fresh_database = pytest.fixture(fresh_database)


@pytest.fixture()
def run_obmd(tmpdir):
    """Set up and start obmd."""
    check_call(['go', 'get', 'github.com/CCI-MOC/obmd'])

    config_file_path = tmpdir + '/obmd-config.json'

    with open(config_file_path, 'w') as f:
        f.write(
            json.dumps({
                'AdminToken': ADMIN_TOKEN,
                'ListenAddr': ':8080',
            }))
Exemplo n.º 39
0
""" Simple tests for odlpp.cuda

This is mostly compilation tests, main suite is in odl
"""

import odlcuda.odlcuda_ as cuda
import pytest

vec_ids = [str(el) for el in dir(cuda) if el.startswith("CudaVector")]
vec_params = [getattr(cuda, vec_id) for vec_id in vec_ids]
vector_type_fixture = pytest.fixture(scope="module", ids=vec_ids, params=vec_params)


@vector_type_fixture
def vector_type(request):
    return request.param


def test_has_vectors():
    # Assert at least 1 vector exists
    assert len(vec_ids) > 0


def test_vector_init(vector_type):
    vec = vector_type(1)
    assert vec is not None


def test_get_set(vector_type):
    vec = vector_type(1)
    vec[0] = 3
Exemplo n.º 40
0
 def disable_setup(request, monkeypatch):
     setup = getattr(request.module, "setup", None)
     isfixture = hasattr(setup, "_pytestfixturefunction")
     if setup is not None and not isfixture and py.builtin.callable(setup):
         monkeypatch.setattr(setup, "_pytestfixturefunction", pytest.fixture(), raising=False)
Exemplo n.º 41
0
import json
import pytest
import requests

from passlib.hash import sha512_crypt

ep = "http://127.0.0.1:8000"
username = "******"
password = "******"

http_client = HybridHTTPClient(endpoint=ep,
                               username=username,
                               password=password)
C = Client(ep, http_client)  # Initializing client library

fail_on_log_warnings = pytest.fixture(fail_on_log_warnings)
fresh_database = pytest.fixture(fresh_database)
server_init = pytest.fixture(server_init)
obmd_cfg = pytest.fixture(obmd_cfg)
intial_db = pytest.fixture(initial_db)


@pytest.fixture
def dummy_verify():
    """replace sha512_crypt.verify with something faster (albeit broken).

    This fixture is for testing User related client calls which use database
    authentication backend.

    This fixture works around a serious consequence of using the database
    backend: doing password hashing is **SLOW** (by design; the algorithms
Exemplo n.º 42
0
@pytest.fixture
def configure():
    """Configure HIL"""
    config_testsuite()
    config_merge({
        'extensions': {
            'hil.ext.switches.brocade': '',
            'hil.ext.switches.dell': '',
            'hil.ext.switches.nexus': '',
        },
    })
    config.load_extensions()


fresh_database = pytest.fixture(fresh_database)
fail_on_log_warnings = pytest.fixture(fail_on_log_warnings)
server_init = pytest.fixture(server_init)
with_request_context = pytest.yield_fixture(with_request_context)

default_fixtures = [
    'fail_on_log_warnings', 'configure', 'fresh_database', 'server_init',
    'with_request_context'
]

pytestmark = pytest.mark.usefixtures(*default_fixtures)


class TestPortValidate:
    """Test port_register with invalid port names for various switches."""
    def test_register_port_invalid_name_brocade(self):
Exemplo n.º 43
0
import pytest

from tests.test_api_non_workspaced_base import GenericAPITest
from tests.factories import UserFactory
from faraday.server.models import User
from faraday.server.api.modules.preferences import PreferencesView
from tests.utils.url import v2_to_v3

pytest.fixture('logged_user')


class TestPreferences(GenericAPITest):
    model = User
    factory = UserFactory
    api_endpoint = 'preferences'
    view_class = PreferencesView

    def test_add_preference(self, test_client):
        preferences = {'field1': 1, 'field2': 'str1'}
        data = {'preferences': preferences}
        response = test_client.post(self.url(), data=data)

        assert response.status_code == 200

        response = test_client.get(self.url())

        assert response.status_code == 200
        assert response.json['preferences'] == preferences

    def test_list_preferences_from_session(self, test_client):
        preferences = {'field1': 1, 'field2': 'str1'}
Exemplo n.º 44
0
import pytest

from owmeta_pytest_plugin import bundle_versions, bundle_fixture_helper

example_bundle = pytest.fixture(bundle_fixture_helper('example/aBundle'))


@bundle_versions('example_bundle', [23])
@pytest.mark.bundle_remote('test')
def test_bundle_remote(owm_project, example_bundle):
    owm_project.fetch(example_bundle)
Exemplo n.º 45
0
import pytest
from uuid import uuid4

from django.contrib.auth.models import AnonymousUser
from django.contrib.messages.storage import default_storage
from django.contrib.sessions.backends.base import SessionBase
from django.core.files.uploadedfile import InMemoryUploadedFile
from django.test.client import RequestFactory as drf
from django.urls import reverse

from caisse.models import Caisse
from mrsrequest.models import MRSRequest
from mrsrequest.views import MRSRequestCreateView


id = mrsrequest_uuid = pytest.fixture(
    lambda: '2b88b740-3920-44e9-b086-c851f58e7ea7')


class RequestFactory(drf):
    def __init__(self, user):
        self.user = user
        super().__init__()

    def generic(self, *args, **kwargs):
        request = super().generic(*args, **kwargs)
        request.session = SessionBase()
        request.user = self.user
        request._messages = default_storage(request)
        return request

Exemplo n.º 46
0
    return _check_real(lambda s, t: [0, 0, 0])


@pytest.fixture
def simple_volume():
    return _check_real(lambda t1, t2, t3: [0, 0, 0])


@pytest.fixture(params=[False, True])
def weyl_system(request):
    """
    Creates a Weyl point system.
    """
    res = z2pack.hm.System(lambda k: np.array([[k[2], k[0] - 1j * k[1]],
                                               [k[0] + 1j * k[1], -k[2]]]))
    if request.param:
        res = OverlapMockSystem(res)
    return res


def weyl_line_creator(kz):
    return lambda t: [np.cos(t * 2 * np.pi), np.sin(t * 2 * np.pi), kz]


weyl_line = pytest.fixture(weyl_line_creator)


@pytest.fixture
def weyl_surface():
    return z2pack.shape.Sphere([0, 0, 0], 1.)
Exemplo n.º 47
0
from protowhat.sct_syntax import (
    ChainedCall,
    ChainExtender,
    EagerChain,
    ExGen,
    LazyChain,
    LazyChainStart,
    state_dec_gen,
)
from tests.helper import state, dummy_checks

sct_dict = {}
Ex = ExGen(sct_dict, None)
state_dec = state_dec_gen(sct_dict)

state = pytest.fixture(state)
dummy_checks = pytest.fixture(dummy_checks)


@pytest.fixture
def addx():
    return lambda state, x: state + x


@pytest.fixture
def f():
    return LazyChain(ChainedCall(lambda state, b: state + b, kwargs={"b":
                                                                     "b"}))


@pytest.fixture
Exemplo n.º 48
0
from jupyter_server.utils import url_path_join
from jupyterlab_server import LabConfig
from tornado.escape import url_escape
from traitlets import Unicode

from jupyterlab.labapp import LabApp


def mkdir(tmp_path, *parts):
    path = tmp_path.joinpath(*parts)
    if not path.exists():
        path.mkdir(parents=True)
    return path


app_settings_dir = pytest.fixture(
    lambda tmp_path: mkdir(tmp_path, "app_settings"))
user_settings_dir = pytest.fixture(
    lambda tmp_path: mkdir(tmp_path, "user_settings"))
schemas_dir = pytest.fixture(lambda tmp_path: mkdir(tmp_path, "schemas"))
workspaces_dir = pytest.fixture(lambda tmp_path: mkdir(tmp_path, "workspaces"))


@pytest.fixture
def make_lab_app(jp_root_dir, jp_template_dir, app_settings_dir,
                 user_settings_dir, schemas_dir, workspaces_dir):
    def _make_lab_app(**kwargs):
        class TestLabApp(LabApp):
            base_url = "/lab"
            extension_url = "/lab"
            default_url = Unicode(
                "/", help="The default URL to redirect to from `/`")
Exemplo n.º 49
0
        enabled_remotes.update(REMOTES)
    else:
        default_enabled = {k for k, v in REMOTES.items() if v}
        enabled_remotes.update(default_enabled)

    for remote_name in REMOTES:
        enabled_opt = _get_opt(remote_name, "enable")
        disabled_opt = _get_opt(remote_name, "disable")

        enabled = config.getoption(enabled_opt)
        disabled = config.getoption(disabled_opt)
        if disabled and enabled:
            continue  # default behavior if both flags are supplied

        if disabled:
            enabled_remotes.discard(remote_name)
        if enabled:
            enabled_remotes.add(remote_name)


@pytest.fixture()
def custom_template(tmp_dir, dvc):
    import shutil

    template = tmp_dir / "custom_template.json"
    shutil.copy(tmp_dir / ".dvc" / "plots" / "default.json", template)
    return template


scriptify_fixture = pytest.fixture(lambda: scriptify, name="scriptify")
Exemplo n.º 50
0
from student import StudentDB
import pytest

pytest.fixture(scope='module')


def db():
    print('============Setup===============')
    db = StudentDB()
    db.connect('data.json')

    return db


# def teardown_module(module):
#  print('============Teardown===============')
#   global db
#  db.close()


def test_scott_data(db):
    scott_data = db.get_data('Scott')

    assert scott_data['id'] == 1
    assert scott_data['name'] == 'Scott'
    assert scott_data['result'] == 'pass'


def test_mark_data(db):
    mark_data = db.get_data('Mark')
Exemplo n.º 51
0
 def fixture(self, *arg, **kw):
     return pytest.fixture(*arg, **kw)
import uuid
import pytest
from fixtures import context, lambda_module  # pylint: disable=import-error
from helpers import mock_table  # pylint: disable=import-error,no-name-in-module

lambda_module = pytest.fixture(scope="module",
                               params=[{
                                   "function_dir": "on_created",
                                   "module_name": "main",
                                   "environ": {
                                       "ENVIRONMENT": "test",
                                       "TABLE_NAME": "TABLE_NAME",
                                       "POWERTOOLS_TRACE_DISABLED": "true"
                                   }
                               }])(lambda_module)
context = pytest.fixture(context)


@pytest.fixture
def order_id():
    return str(uuid.uuid4())


@pytest.fixture
def payment_token():
    return str(uuid.uuid4())


def test_save_payment_token(lambda_module, order_id, payment_token):
    """
    Test save_payment_token()
Exemplo n.º 53
0
        exc = LoggedFailure("foo")
        assert exc.message[0] == '\x1b', "Message starts with ANSI sequence"


class GroupMock(Group, list):
    def get_command(self, ctx, cmd_name):
        self.append((ctx, cmd_name))


class AliasedGroupWithMock(AliasedGroup, GroupMock):
    """Go watch Raymond's ‘Super considered super!’ @ https://youtu.be/EiOglTERPEo"""

    MAP = dict(foo='bar')


aliased_group = pytest.fixture()(lambda: AliasedGroupWithMock())


class AliasedGroupTests():
    def test_alias_group_maps_to_canonical_name(self, aliased_group):
        aliased_group.get_command(None, 'foo')
        assert aliased_group == [(None, 'bar')]

    def test_alias_group_passes_on_unmapped_name(self, aliased_group):
        aliased_group.get_command(None, 'foobar')
        assert aliased_group == [(None, 'foobar')]


class ConfigurationTests():
    def test_configuration_from_context_creation_works(self):
        ctx = Bunch(info_name='foobarbaz', obj=None)
Exemplo n.º 54
0
#        http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS,
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.
"""
Fixtures for writing tests that execute WDL workflows using Cromwell. For testability
purposes, the implementaiton of these fixtures is done in the pytest_wdl.fixtures
module.
"""
from pytest_wdl import fixtures
import pytest

user_config_file = pytest.fixture(scope="session")(fixtures.user_config_file)
user_config = pytest.fixture(scope="session")(fixtures.user_config)
project_root_files = pytest.fixture(scope="module")(
    fixtures.project_root_files)
project_root = pytest.fixture(scope="module")(fixtures.project_root)
workflow_data_descriptor_file = pytest.fixture(scope="module")(
    fixtures.workflow_data_descriptor_file)
workflow_data_descriptors = pytest.fixture(scope="module")(
    fixtures.workflow_data_descriptors)
workflow_data_resolver = pytest.fixture(scope="module")(
    fixtures.workflow_data_resolver)
workflow_data = pytest.fixture(scope="function")(fixtures.workflow_data)
import_paths = pytest.fixture(scope="module")(fixtures.import_paths)
import_dirs = pytest.fixture(scope="module")(fixtures.import_dirs)
workflow_runner = pytest.fixture(scope="function")(fixtures.workflow_runner)
Exemplo n.º 55
0
def polygon_without_type(polygon):
    """a GeoJSON Polygon without a type key"""
    del polygon['type']
    return polygon


@pytest.fixture
def text_file(tmpdir):
    """a file that does not contain valid JSON"""
    f = tmpdir.join('test.txt')
    with f.open('w', encoding='ascii') as tmpfile:
        tmpfile.write('plaintext')
    return str(f)


@pytest.fixture
def unequal_positions(position):
    """a 2-tuple pair of distinct GeoJSON Position"""
    position2 = list(position)
    position2[0] = position[0] + 1
    return position, position2


# Make functions in gjtk.random fixtures:
for name in dir(gjtk.random):
    if name.startswith('_'):
        continue
    attr = getattr(gjtk.random, name)
    if callable(attr):
        globals()[name] = pytest.fixture(attr, name=name)
Exemplo n.º 56
0
from bs4 import BeautifulSoup as Soup
from .fixtures import app_client
import pytest
import re
import urllib.parse

pytest.fixture(scope='module')(app_client)


def test_homepage(app_client):
    response = app_client.get('/', gather_request=False)
    assert response.status == 200
    assert 'test_tables' in response.text


def test_database_page(app_client):
    response = app_client.get('/test_tables',
                              allow_redirects=False,
                              gather_request=False)
    assert response.status == 302
    response = app_client.get('/test_tables', gather_request=False)
    assert 'test_tables' in response.text


def test_invalid_custom_sql(app_client):
    response = app_client.get('/test_tables?sql=.schema', gather_request=False)
    assert response.status == 400
    assert 'Statement must be a SELECT' in response.text


def test_view(app_client):
Exemplo n.º 57
0
import test.integration.fixtures


def is_gz_file(filepath):
    with open(filepath, 'rb') as test_f:
        return binascii.hexlify(test_f.read(2)) == b'1f8b'


def find_files(root_dir, filt):
    matches = []
    for root, dirnames, filenames in os.walk(root_dir):
        for filename in fnmatch.filter(filenames, filt):
            yield join(root, filename)


krona = pytest.fixture(scope='module')(test.integration.fixtures.krona)
krona_db = pytest.fixture(scope='module')(test.integration.fixtures.krona_db)
taxonomy_db = pytest.fixture(scope='module')(test.integration.fixtures.taxonomy_db)


@pytest.fixture(scope='module')
def fastq_to_sam():
    return tools.picard.FastqToSamTool()


@pytest.fixture(scope='module')
def sam_to_fastq():
    return tools.picard.SamToFastqTool()


@pytest.fixture(scope='module')
Exemplo n.º 58
0
@pytest.fixture
def configure():
    config_testsuite()
    config_merge({
        'haas.ext.switches.dell': {
            'save': 'True'
        },
        'haas.ext.switches.nexus': {
            'save': 'True'
        }
    })
    config.load_extensions()


fail_on_log_warnings = pytest.fixture(autouse=True)(fail_on_log_warnings)
fresh_database = pytest.fixture(fresh_database)


@pytest.fixture
def server_init():
    server.register_drivers()
    server.validate_state()


with_request_context = pytest.yield_fixture(with_request_context)

site_layout = pytest.fixture(site_layout)

pytestmark = pytest.mark.usefixtures('configure', 'server_init',
                                     'fresh_database', 'with_request_context',
Exemplo n.º 59
0
    return fresh_database(request)


@pytest.fixture
def server_init():
    server.register_drivers()
    server.validate_state()


@pytest.yield_fixture
def with_request_context():
    with rest.RequestContext():
        yield


site_layout = pytest.fixture(site_layout)

pytestmark = pytest.mark.usefixtures("configure", "server_init", "db", "with_request_context", "site_layout")


class TestNativeNetwork(NetworkTest):
    def test_isolated_networks(self, db):
        def create_networks():
            nodes = self.collect_nodes(db)

            # Create two networks
            network_create_simple("net-0", "anvil-nextgen")
            network_create_simple("net-1", "anvil-nextgen")

            ports = self.get_all_ports(nodes)
Exemplo n.º 60
0
from jupyterlab import LabApp
from jupyterlab_server import LabConfig
from jupyterlab_server.tests.utils import here
from jupyterlab_server.app import LabServerApp
from jupyter_server.utils import url_path_join


def mkdir(tmp_path, *parts):
    path = tmp_path.joinpath(*parts)
    if not path.exists():
        path.mkdir(parents=True)
    return path


app_settings_dir = pytest.fixture(
    lambda tmp_path: mkdir(tmp_path, 'app_settings'))
user_settings_dir = pytest.fixture(
    lambda tmp_path: mkdir(tmp_path, 'user_settings'))
schemas_dir = pytest.fixture(lambda tmp_path: mkdir(tmp_path, 'schemas'))
workspaces_dir = pytest.fixture(lambda tmp_path: mkdir(tmp_path, 'workspaces'))


@pytest.fixture
def make_lab_app(jp_root_dir, jp_template_dir, app_settings_dir,
                 user_settings_dir, schemas_dir, workspaces_dir):
    def _make_lab_app(**kwargs):
        class TestLabApp(LabApp):
            base_url = '/lab'
            extension_url = '/lab'
            default_url = Unicode(
                '/', help='The default URL to redirect to from `/`')