zope.pytestlayer 8.2__py3-none-any.whl

zope/pytestlayer/_compat.py

@@ -0,0 +1,18 @@
+# copied from Python 2.7 source code as plone testing uses __bases__
+def _searchbases(cls, accum):
+    # Simulate the "classic class" search order.
+    if cls in accum:
+        return
+    accum.append(cls)
+    for base in cls.__bases__:
+        _searchbases(base, accum)
+
+
+def getmro(cls):
+    """Return tuple of base classes in method resolution order."""
+    if hasattr(cls, "__mro__"):
+        return cls.__mro__
+    else:
+        result = []
+        _searchbases(cls, result)
+        return tuple(result)

zope/pytestlayer/doctest.py

@@ -0,0 +1,31 @@
+import doctest
+
+
+class NoOpLayer:
+    """Layer needed for zope.pytestlayer to find and run doctests.
+
+    See https://github.com/zope/zope.pytestlayer/issues/4
+    """
+
+    __name__ = 'NoOpLayer'
+    __bases__ = ()
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+
+NOOP_LAYER = NoOpLayer()
+
+
+def DocTestSuite(*args, **kw):
+    """A DocTestSuite whose tests are detectable by zope.pytestlayer.
+
+    See https://github.com/zope/zope.pytestlayer/issues/4
+    """
+    layer = kw.pop('layer', NOOP_LAYER)
+    suite = doctest.DocTestSuite(*args, **kw)
+    suite.layer = layer
+    return suite

zope/pytestlayer/fixture.py

@@ -0,0 +1,234 @@
+import contextlib
+import re
+import time
+import types
+
+import pytest
+import zope.dottedname.resolve
+
+
+class ZopeLayerState(object):
+
+    def __init__(self):
+        self.current = set()
+        self.keep = set()
+        self.keep_for_whole_session = set()
+
+
+@contextlib.contextmanager
+def timer(request, text):
+    verbose = request.config.option.verbose > 0
+    reporter = request.config.pluginmanager.getplugin('terminalreporter')
+    if verbose:
+        reporter.ensure_newline()
+        reporter.write(text)
+        start = time.time()
+    yield
+    if verbose:
+        time_taken = time.time() - start
+        reporter.write(f"{time_taken:.3f}", green=1, bold=1)
+        reporter.write_line(" seconds.")
+
+
+def setup_layer(layer, request):
+    decorate_layer(layer, request)
+    state = request.session.zopelayer_state
+    layer_name = get_layer_name(layer)
+    if hasattr(layer, 'setUp'):
+        print(layer_name)
+        with timer(request, f"Set up {layer_name} in "):
+            layer.setUp()
+        state.current.add(layer)
+
+
+def teardown_layer(layer, request):
+    decorate_layer(layer, request)
+    state = request.session.zopelayer_state
+    layer_name = get_layer_name(layer)
+    if hasattr(layer, 'tearDown'):
+        with timer(request, f"Tear down {layer_name} in "):
+            layer.tearDown()
+        state.current.remove(layer)
+
+
+def session_fixture(request, layer):
+    state = request.session.zopelayer_state
+    if layer not in state.current:
+        setup_layer(layer, request)
+        state.keep_for_whole_session.add(layer)
+
+    def teardown():
+        teardown_layer(layer, request)
+    request.addfinalizer(teardown)
+    return layer
+
+
+def class_fixture(request, layer):
+    state = request.session.zopelayer_state
+    if layer not in state.current:
+        setup_layer(layer, request)
+
+    def maybe_teardown():
+        if layer not in (state.keep | state.keep_for_whole_session):
+            teardown_layer(layer, request)
+    request.addfinalizer(maybe_teardown)
+    return layer
+
+
+def function_fixture(request, layer):
+    decorate_layer(layer, request)
+    if hasattr(layer, 'testSetUp'):
+        layer.testSetUp()
+
+    if hasattr(layer, 'testTearDown'):
+
+        def function_tear_down():
+            decorate_layer(layer, request)
+            layer.testTearDown()
+
+        request.addfinalizer(function_tear_down)
+    return layer
+
+
+def decorate_layer(layer, request):
+    setattr(layer, 'pytest_request', request)
+
+
+def get_layer_name(layer):
+    module = zope.dottedname.resolve.resolve(layer.__module__)
+    for key, value in module.__dict__.items():
+        if value is layer:
+            name = key
+            break
+    else:
+        # As per zope.testrunner conventions, a layer is assumed to have a
+        # __name__ even if it's not a class.
+        name = layer.__name__
+    return '%s.%s' % (layer.__module__, name)
+
+
+def make_identifier(string):
+    # Replaces things between words into underscores:
+    return re.sub(r'\W|^(?=\d)', '_', string)
+
+
+def get_fixture_name(layer, scope):
+    name = make_identifier(get_layer_name(layer))
+    layerid = id(layer)
+    return 'zope_layer_{scope}_{name}_{layerid}'.format(**locals())
+
+
+LAYERS = {}
+LAYERS[object] = {}  # We do not need to create a fixture for `object`
+
+
+def create(*layers, **kw):
+    """Create fixtures for given layers and their bases.
+
+    Fixture names will be generated automatically. For a single layer, you can
+    pass in kw arguments ``session_fixture_name, ``class_fixture_name`` and
+    ``function_fixture_name`` instead.
+
+    """
+    if kw and len(layers) > 1:
+        raise ValueError(
+            'Overriding layer names is only possible '
+            'for a single layer at a time')
+
+    ns = {}
+    for layer in layers:
+        if isinstance(layer, str):
+            layer = zope.dottedname.resolve.resolve(layer)
+        ns.update(_create_single(layer, **kw))
+    return ns
+
+
+SCOPES = ('session', 'class', 'function')
+TEMPLATE = """\
+@pytest.fixture(scope='session')
+def {session_fixture_name}(request{session_fixture_dependencies}):
+    "Depends on {session_fixture_dependencies}"
+    return session_fixture(request, layer)
+
+@pytest.fixture(scope='class')
+def {class_fixture_name}(request{class_fixture_dependencies}):
+    "Depends on {class_fixture_dependencies}"
+    return class_fixture(request, layer)
+
+@pytest.fixture(scope='function')
+def {function_fixture_name}(request{function_fixture_dependencies}):
+    "Depends on {function_fixture_dependencies}"
+    return function_fixture(request, layer)
+"""
+
+
+def _create_single(layer, **kw):
+    """Actually create a fixtures for a single layer and its bases."""
+    if layer in LAYERS:
+        return {}
+
+    LAYERS[layer] = {}
+    dependencies = {}
+    for scope in SCOPES:
+        LAYERS[layer][scope] = kw.get(
+            '%s_fixture_name' % scope, get_fixture_name(layer, scope))
+        dependencies[scope] = [
+            ', ' + LAYERS.get(base, {}).get(
+                scope, get_fixture_name(base, scope))
+            for base in layer.__bases__ if base is not object]
+    dependencies['function'].insert(0, ', ' + LAYERS[layer]['class'])
+
+    fixtures = {}
+    for scope in SCOPES:
+        fixtures['%s_fixture_name' % scope] = LAYERS[layer][scope]
+        fixtures['%s_fixture_dependencies' % scope] = ''.join(
+            dependencies[scope])
+    code = TEMPLATE.format(**fixtures)
+
+    globs = {
+        'pytest': pytest,
+        'layer': layer,
+    }
+    for scope in SCOPES:
+        globs['%s_fixture' % scope] = globals()['%s_fixture' % scope]
+
+    ns = {}
+    exec(code, globs, ns)
+
+    # Recurse into bases:
+    ns.update(create(*layer.__bases__))
+
+    return ns
+
+
+def parsefactories(collector, layer):
+    ns = create(layer)
+    if ns:
+        name = get_fixture_name(layer, scope='function')
+        module = types.ModuleType(name)
+        module.__dict__.update(ns)
+        collector.session._fixturemanager.parsefactories(module, '')
+
+
+def raise_if_bad_layer(layer):
+    'complaining about bad layers'
+
+    if not hasattr(layer, '__bases__'):
+        raise RuntimeError(
+            "The layer {layer!r} has no __bases__ attribute."
+            " Layers may be of two sorts: class or instance with __bases__"
+            " attribute."
+        )
+
+
+KEYWORDS_BY_LAYER = {object: {}}
+
+
+def get_keywords(layer):
+    if layer in KEYWORDS_BY_LAYER:
+        return KEYWORDS_BY_LAYER[layer]
+    keywords = {get_layer_name(layer): True}
+    for base_layer in layer.__bases__:
+        keywords.update(get_keywords(base_layer))
+    KEYWORDS_BY_LAYER[layer] = keywords
+    return keywords

zope/pytestlayer/layered.py

@@ -0,0 +1,100 @@
+import unittest
+
+import _pytest.unittest
+import pytest
+
+from zope.pytestlayer import fixture
+
+
+class LayeredTestSuite(pytest.Class):
+
+    def collect(self):
+        suite = self.obj()
+        for item, layer in walk_suite(suite):
+            fixture.parsefactories(self.parent, layer)
+            yield LayeredTestCaseInstance.from_parent(
+                parent=self, obj=item, layer=layer)
+
+
+class LayeredTestCaseInstance(_pytest.unittest.UnitTestCase):
+
+    @classmethod
+    def from_parent(cls, parent, obj, layer, **kw):
+        testname = repr(obj)  # fantastic doctest API :(
+        instance = super(pytest.Collector, cls).from_parent(
+            parent=parent, name=testname)
+        # store testcase instance and layer
+        # to pass them to function
+        instance.obj = obj
+        instance.layer = layer
+        instance.extra_keyword_matches.update(fixture.get_keywords(layer))
+        return instance
+
+    def collect(self):
+        yield LayeredTestCaseFunction.from_parent(parent=self, name='runTest')
+
+    def reportinfo(self):
+        pass
+
+
+class LayeredTestCaseFunction(_pytest.unittest.TestCaseFunction):
+
+    @classmethod
+    def from_parent(cls, parent, name, **kw):
+        description = get_description(parent)
+        keywords = get_keywords(description)
+        function = super(LayeredTestCaseFunction, cls).from_parent(
+            parent=parent,
+            name=name,
+            keywords=keywords,
+        )
+        function.layer = function.parent.layer
+        function.tc_description = description
+        function._testcase = function.parent.obj
+        return function
+
+    def setup(self):
+        # This is actually set in the base class, but as we want to modify
+        # `self._request` in our way, we do not make a super call here.
+        # It has to be None or a bound method to be called during tearDown.
+        self._explicit_tearDown = None
+        if hasattr(self, "_request"):
+            # call function fixture (testSetUp)
+            fixture_name = fixture.get_fixture_name(
+                self.layer, scope='function')
+            self._request.getfixturevalue(fixture_name)
+
+    def teardown(self):
+        _testcase = self._testcase
+        super(LayeredTestCaseFunction, self).teardown()
+        # Do not die with a meaningless error message when rerunning doctests:
+        self._testcase = _testcase
+
+    def reportinfo(self):
+        return ('test_suite', None, self.tc_description)
+
+
+def get_description(collector):
+    description = str(collector.obj)
+    fspath = collector.session.fspath.strpath
+    return description.replace(fspath, '')
+
+
+def get_keywords(description):
+    words = [word for word in description.split()]
+    keywords = {}
+    for word in words:
+        keywords[word] = True
+    return keywords
+
+
+def walk_suite(suite):
+    if isinstance(suite, unittest.TestSuite):
+        has_layer = hasattr(suite, 'layer')
+        for item in suite:
+            if isinstance(item, unittest.TestCase) and has_layer:
+                fixture.raise_if_bad_layer(suite.layer)
+                yield item, suite.layer
+            else:
+                for result in walk_suite(item):
+                    yield result

zope/pytestlayer/plugin.py

@@ -0,0 +1,122 @@
+import types
+import unittest
+
+import pytest
+
+from zope.pytestlayer import fixture
+from zope.pytestlayer import layered
+
+from ._compat import getmro
+
+
+@pytest.mark.tryfirst
+def pytest_pycollect_makeitem(collector, name, obj):
+    # this works because of two things:
+    # * this plugin is called before the pytest unittest collector (if it
+    #   wasn't, it wouldn't be called at all after the pytest collector has
+    #   detected a unittest test case)
+    # * usefixtures works in-place
+
+    suite = query_testsuite(obj)
+    if suite is not None:
+        return layered.LayeredTestSuite.from_parent(
+            parent=collector, name=name)
+    else:
+        layer = query_layer(obj)
+        if layer is not None:
+            fixture.parsefactories(collector, layer)
+            return collect_with_layer(collector, name, obj, layer)
+
+
+def query_testsuite(obj):
+    if (isinstance(obj, types.FunctionType) and obj.__name__ == 'test_suite'):
+        suite = obj()
+        if isinstance(suite, unittest.TestSuite):
+            return suite
+
+
+def query_layer(obj):
+    if has_layer(obj):
+        layer = obj.layer
+        fixture.raise_if_bad_layer(layer)
+        return layer
+
+
+def has_layer(obj):
+    try:
+        isunit = issubclass(obj, unittest.TestCase)
+    except TypeError:
+        isunit = False
+    return isunit and hasattr(obj, 'layer')
+
+
+def pytest_collection_modifyitems(session, config, items):
+    items_by_layer = {}
+    layers_in_order = []
+    for item in items:
+        if hasattr(item, 'cls') and hasattr(item.cls, 'layer'):
+            layer = item.cls.layer
+            layers_in_order.append(layer)
+        elif hasattr(item, 'layer'):
+            layer = item.layer
+            layers_in_order.append(layer)
+        else:
+            layer = None
+        items_by_layer.setdefault(layer, []).append(item)
+    ordered_layers = order_by_bases(layers_in_order)
+    items[:] = items_by_layer.get(None, [])
+    for layer in ordered_layers:
+        items.extend(items_by_layer.get(layer, []))
+
+
+def order_by_bases(layers):
+    """Order the layers from least to most specific (bottom to top)
+    """
+    gathered = []
+    for layer in layers:
+        gather_layers(layer, gathered)
+    seen = set()
+    result = []
+    for layer in gathered:
+        if layer not in seen:
+            seen.add(layer)
+            if layer in layers:
+                result.append(layer)
+    return result
+
+
+def gather_layers(layer, result):
+    for b in layer.__bases__:
+        gather_layers(b, result)
+    if layer is not object:
+        result.append(layer)
+
+
+def pytest_sessionstart(session):
+    session.zopelayer_state = fixture.ZopeLayerState()
+
+
+def pytest_runtest_teardown(item, nextitem):
+    state = item.session.zopelayer_state
+
+    if hasattr(nextitem, 'cls') and hasattr(nextitem.cls, 'layer'):
+        state.keep = state.current & set(getmro(nextitem.cls.layer))
+    elif hasattr(nextitem, 'layer'):
+        state.keep = state.current & set(getmro(nextitem.layer))
+    else:
+        state.keep.clear()
+
+
+def collect_with_layer(collector, name, obj, layer):
+    fixture_name = fixture.LAYERS.get(layer, {}).get(
+        'function', fixture.get_fixture_name(layer, 'function'))
+    usefixtures = pytest.mark.usefixtures(fixture_name)
+    usefixtures(obj)
+    py_unittest = get_py_unittest(collector)
+    result = py_unittest.pytest_pycollect_makeitem(collector, name, obj)
+    result.extra_keyword_matches.update(fixture.get_keywords(layer))
+    return result
+
+
+def get_py_unittest(collector):
+    return collector.session.config.pluginmanager.getplugin('unittest')

zope/pytestlayer/testing.py

@@ -0,0 +1,6 @@
+def log_to_terminal(request, msg):
+    verbose = request.config.option.verbose > 0
+    if verbose:
+        reporter = request.config.pluginmanager.getplugin('terminalreporter')
+        reporter.ensure_newline()
+        reporter.write_line(msg)

zope/pytestlayer/tests/conftest.py

@@ -0,0 +1,3 @@
+def pytest_ignore_collect(path, config):
+    if path.strpath.endswith('fixture'):
+        return True

zope/pytestlayer/tests/fixture/bad_layer/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ('zopelayer', )

zope/pytestlayer/tests/fixture/bad_layer/test_core.py

@@ -0,0 +1,13 @@
+import unittest
+
+
+class FooLayer(object):
+    __name__ = 'FooLayer'
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer()
+
+    def test_dummy(self):
+        self.assertEqual(1, 1)

zope/pytestlayer/tests/fixture/custom_fixture_name/conftest.py

@@ -0,0 +1,12 @@
+from custom_fixture_name.test_core import FooLayer
+
+import zope.pytestlayer.fixture
+
+
+pytest_plugins = ('zopelayer', )
+
+
+globals().update(zope.pytestlayer.fixture.create(
+    FooLayer,
+    class_fixture_name='foo_layer_class',
+    function_fixture_name='foo_layer'))

zope/pytestlayer/tests/fixture/custom_fixture_name/test_core.py

@@ -0,0 +1,38 @@
+import unittest
+
+from zope.pytestlayer.testing import log_to_terminal
+
+
+class FooLayer(object):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_foo = 'layer foo'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_foo
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp foo')
+        cls.test_foo = 'test foo'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown foo')
+        del cls.test_foo
+
+
+def test_can_access_layer_via_fixture(foo_layer):
+    assert 'layer foo' == foo_layer.layer_foo
+    assert 'test foo' == foo_layer.test_foo
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer
+
+    def test_accesses_fixture_with_generated_name_for_layer(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)

zope/pytestlayer/tests/fixture/keep_layer_across_test_classes/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ('zopelayer', )