nti.testing 4.2.0__py3-none-any.whl

nti/testing/layers/zope.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Test layers for working with Zope libraries.
+
+"""
+
+import gc
+import logging
+
+
+from zope import component
+from zope.component import eventtesting
+from zope.component.hooks import setHooks
+
+from .. import transactionCleanUp
+from ..base import AbstractConfiguringObject
+from .cleanup import SharedCleanupLayer
+
+logger = logging.getLogger(__name__)
+
+class ZopeComponentLayer(SharedCleanupLayer):
+    """
+    Test layer that can be subclassed when zope.component will be used.
+
+    This does nothing but set up the hooks and the event handlers.
+    """
+
+    @classmethod
+    def setUp(cls):
+        setHooks() # zope.component.hooks registers a zope.testing.cleanup to reset these
+
+
+    @classmethod
+    def tearDown(cls):
+        # always safe to clear events
+        eventtesting.clearEvents() # redundant with zope.testing.cleanup
+        # we never actually want to do this, it's not needed and can mess up other fixtures
+        # resetHooks()
+
+    @classmethod
+    def testSetUp(cls):
+        setHooks() # ensure these are still here; cheap and easy
+
+    @classmethod
+    def testTearDown(cls):
+        # Some tear down needs to happen always
+        eventtesting.clearEvents()
+        transactionCleanUp()
+
+_marker = object()
+
+class ConfiguringLayerMixin(AbstractConfiguringObject):
+    """
+    Inherit from this layer *at the leaf level* to perform configuration.
+    You should have already inherited from :class:`ZopeComponentLayer`.
+
+    To use this layer, subclass it and define a set of packages. This
+    should be done EXACTLY ONCE for each set of packages; things that
+    add to the set of packages should generally extend that layer
+    class. You must call :meth:`setUpPackages` and :meth:`tearDownPackages`
+    from your ``setUp`` and ``tearDown`` methods.
+
+    See :class:`~.AbstractConfiguringObject` for documentation on
+    the class attributes to configure.
+    """
+
+    @classmethod
+    def setUp(cls):
+        # You MUST implement this, otherwise zope.testrunner
+        # will call the super-class again
+        pass
+
+    @classmethod
+    def tearDown(cls):
+        # You MUST implement this, otherwise zope.testrunner
+        # will call the super-class again
+        pass
+
+    @classmethod
+    def testSetUp(cls):
+        pass
+
+    @classmethod
+    def testTearDown(cls):
+        # Must implement
+        pass
+
+    #: .. seealso:: :meth:`~.AbstractConfiguringObject.get_configuration_package_for_class`
+    #: .. versionadded:: 2.1.0
+    get_configuration_package = classmethod(
+        AbstractConfiguringObject.get_configuration_package_for_class
+    )
+
+    @classmethod
+    def setUpPackages(cls):
+        """
+        Set up the configured packages.
+        """
+        logger.info('Setting up packages %s for layer %s', cls.set_up_packages, cls)
+        gc.collect()
+        cls.configuration_context = cls.configure_packages(
+            set_up_packages=cls.set_up_packages,
+            features=cls.features,
+            context=cls.configuration_context,
+            package=cls.get_configuration_package())
+        component.provideHandler(eventtesting.events.append, (None,))
+        gc.collect()
+
+    configure_packages = classmethod(AbstractConfiguringObject._do_configure_packages)
+
+    @classmethod
+    def tearDownPackages(cls):
+        """
+        Tear down all configured packages in the global site manager.
+        """
+        # This is a duplicate of zope.component.globalregistry
+        logger.info('Tearing down packages %s for layer %s', cls.set_up_packages, cls)
+        gc.collect()
+        component.getGlobalSiteManager().__init__('base') # pylint:disable=unnecessary-dunder-call
+        gc.collect()
+        cls.configuration_context = None

nti/testing/matchers.py

@@ -0,0 +1,370 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Hamcrest matchers for testing.
+"""
+
+from collections.abc import Sequence, Mapping
+
+import pprint
+
+import six
+from zope.interface.exceptions import Invalid
+from zope.interface.verify import verifyObject
+from zope.schema import ValidationError
+from zope.schema import getValidationErrors
+
+
+import hamcrest
+from hamcrest import assert_that
+from hamcrest import has_length
+from hamcrest import is_
+from hamcrest import is_not
+from hamcrest.core.base_description import BaseDescription
+from hamcrest.core.base_matcher import BaseMatcher
+from hamcrest.library.collection.is_empty import empty
+
+__docformat__ = "restructuredtext en"
+
+__all__ = [
+    'has_length',
+    'has_attr',
+    'is_true',
+    'is_false',
+    'provides',
+    'verifiably_provides',
+    'validly_provides',
+    'implements',
+    'validated_by',
+    'not_validated_by',
+    'aq_inContextOf',
+    'TypeCheckedDict',
+]
+
+is_empty = empty # bwc
+
+has_attr = hamcrest.library.has_property
+
+class BoolMatcher(BaseMatcher):
+    def __init__(self, value):
+        super().__init__()
+        self.value = value
+
+    def _matches(self, item):
+        return bool(item) == self.value
+
+    def describe_to(self, description):
+        description.append_text('object with bool() value ').append(str(self.value))
+
+    def __repr__(self):
+        return 'object with bool() value ' + str(self.value)
+
+def is_true():
+    """
+    Matches an object with a true boolean value.
+    """
+    return BoolMatcher(True)
+
+def is_false():
+    """
+    Matches an object with a false boolean value.
+    """
+    return BoolMatcher(False)
+
+class Provides(BaseMatcher):
+
+    def __init__(self, iface):
+        super().__init__()
+        self.iface = iface
+
+    def _matches(self, item):
+        return self.iface.providedBy(item)
+
+    def describe_to(self, description):
+        description.append_text('object providing') \
+                                 .append(str(self.iface))
+
+    def __repr__(self):
+        return 'object providing' + str(self.iface)
+
+
+def provides(iface):
+    """
+    Matches an object that provides the given interface.
+    """
+    return Provides(iface)
+
+
+class VerifyProvides(BaseMatcher):
+
+    def __init__(self, iface):
+        super().__init__()
+        self.iface = iface
+
+    def _matches(self, item):
+        try:
+            verifyObject(self.iface, item)
+        except Invalid:
+            return False
+        return True
+
+    def describe_to(self, description):
+        description.append_text('object verifiably providing ').append_description_of(self.iface)
+
+    def describe_mismatch(self, item, mismatch_description):
+        md = mismatch_description
+
+        try:
+            verifyObject(self.iface, item)
+        except Invalid as x:
+            # Beginning in zope.interface 5, the Invalid exception subclasses
+            # like BrokenImplementation, DoesNotImplement, etc, all typically
+            # have a much nicer error message than they used to, better than we
+            # were producing. This is especially true now that MultipleInvalid
+            # is a thing.
+            x = str(x).strip()
+
+            md.append_text("Using class ").append_description_of(type(item)).append_text(' ')
+            if x.startswith('The object '):
+                x = x[len("The object "):]
+                x = 'the object ' + x
+            x = x.replace('\n    ', '\n          ')
+            md.append_text(x)
+
+
+def verifiably_provides(*ifaces):
+    """
+    Matches if the object verifiably provides the correct interface(s),
+    as defined by :func:`zope.interface.verify.verifyObject`. This means having the right attributes
+    and methods with the right signatures.
+
+    .. note:: This does **not** test schema compliance. For that
+        (stricter) test, see :func:`validly_provides`.
+
+    """
+    if len(ifaces) == 1:
+        return VerifyProvides(ifaces[0])
+
+    return hamcrest.all_of(*[VerifyProvides(x) for x in ifaces])
+
+
+class VerifyValidSchema(BaseMatcher):
+    def __init__(self, iface):
+        super().__init__()
+        self.iface = iface
+
+    def _matches(self, item):
+        errors = getValidationErrors(self.iface, item)
+        return not errors
+
+    def describe_to(self, description):
+        description.append_text('object validly providing ').append(str(self.iface))
+
+    def describe_mismatch(self, item, mismatch_description):
+        x = None
+        md = mismatch_description
+        md.append_text(str(type(item)))
+
+        errors = getValidationErrors(self.iface, item)
+
+        for attr, exc in errors:
+            try:
+                raise exc
+            except ValidationError:
+                md.append_text(' has attribute "')
+                md.append_text(attr)
+                md.append_text('" with error "')
+                md.append_text(repr(exc))
+                md.append_text('"\n\t ')
+            except Invalid as x: # pragma: no cover
+                md.append_text(str(x))
+
+
+def validly_provides(*ifaces):
+    """
+    Matches if the object verifiably and validly provides the given
+    schema (interface(s)).
+
+    Verification is done with :mod:`zope.interface` and
+    :func:`verifiably_provides`, while validation is done with
+    :func:`zope.schema.getValidationErrors`.
+    """
+    if len(ifaces) == 1:
+        the_schema = ifaces[0]
+        return hamcrest.all_of(verifiably_provides(the_schema), VerifyValidSchema(the_schema))
+
+    prov = verifiably_provides(*ifaces)
+    valid = [VerifyValidSchema(x) for x in ifaces]
+
+    return hamcrest.all_of(prov, *valid)
+
+
+
+class Implements(BaseMatcher):
+
+    def __init__(self, iface):
+        super().__init__()
+        self.iface = iface
+
+    def _matches(self, item):
+        return self.iface.implementedBy(item)
+
+    def describe_to(self, description):
+        description.append_text('object implementing')
+        description.append_description_of(self.iface)
+
+def implements(iface):
+    """
+    Matches if the object implements (is a factory for) the given
+    interface.
+
+    .. seealso:: :meth:`zope.interface.interfaces.ISpecification.implementedBy`
+    """
+    return Implements(iface)
+
+
+class ValidatedBy(BaseMatcher):
+
+    def __init__(self, field, invalid=Invalid):
+        super().__init__()
+        self.field = field
+        self.invalid = invalid
+
+    def _matches(self, item):
+        try:
+            self.field.validate(item)
+        except self.invalid:
+            return False
+
+        return True
+
+    def describe_to(self, description):
+        description.append_text('data validated by').append_description_of(self.field)
+
+    def describe_mismatch(self, item, mismatch_description):
+        ex = None
+        try:
+            self.field.validate(item)
+        except self.invalid as e:
+            ex = e
+
+        mismatch_description.append_description_of(self.field)
+        mismatch_description.append_text(' failed to validate ')
+        mismatch_description.append_description_of(item)
+        mismatch_description.append_text(' with ')
+        mismatch_description.append_description_of(ex)
+
+def validated_by(field, invalid=Invalid):
+    """
+    Matches if the data is validated by the given ``IField``.
+
+    :keyword exception invalid: The types of exceptions that are considered
+        invalid. Anything other than this is allowed to be raised.
+
+    .. versionchanged:: 2.0.1
+       Add ``invalid`` and change it from ``Exception`` to
+       :class:`zope.interface.interfaces.Invalid`
+    """
+    return ValidatedBy(field, invalid=invalid)
+
+def not_validated_by(field, invalid=Invalid):
+    """
+    Matches if the data is NOT validated by the given IField.
+
+    :keyword exception invalid: The types of exceptions that are considered
+        invalid. Anything other than this is allowed to be raised.
+
+    .. versionchanged:: 2.0.1
+       Add ``invalid`` and change it from ``Exception`` to
+       :class:`zope.interface.interfaces.Invalid`
+    """
+    return is_not(validated_by(field, invalid=invalid))
+
+def _aq_inContextOf_NotImplemented(child, parent): # pylint:disable=unused-argument
+    return False
+
+try:
+    from Acquisition import aq_inContextOf as _aq_inContextOf
+except ImportError: # pragma: no cover
+    # acquisition not installed
+    _aq_inContextOf = _aq_inContextOf_NotImplemented
+
+
+class AqInContextOf(BaseMatcher):
+    def __init__(self, parent):
+        super().__init__()
+        self.parent = parent
+
+    def _matches(self, item):
+        if hasattr(item, 'aq_inContextOf'): # wrappers
+            return item.aq_inContextOf(self.parent)
+        return _aq_inContextOf(item, self.parent) # not wrapped, but maybe __parent__ chain
+
+    def describe_to(self, description):
+        description.append_text('object in context of ')
+        description.append_description_of(self.parent)
+
+    def describe_mismatch(self, item, mismatch_description):
+        if _aq_inContextOf is _aq_inContextOf_NotImplemented:
+            mismatch_description.append_text('Acquisition was not installed.')
+            return
+
+        mismatch_description.append_description_of(item)
+        mismatch_description.append_text(' was not in the context of ')
+        mismatch_description.append_description_of(self.parent)
+        mismatch_description.append_text('; its lineage is ')
+        lineage = []
+        while item is not None:
+            try:
+                item = item.__parent__
+            except AttributeError:
+                item = None
+            if item is not None:
+                lineage.append(item)
+        mismatch_description.append_description_of(lineage)
+
+
+def aq_inContextOf(parent):
+    """
+    Matches if the data is in the acquisition context of
+    the given object.
+    """
+    return AqInContextOf(parent)
+
+# Patch hamcrest for better descriptions of maps (json data)
+# and sequences
+if six.PY3:
+    from io import StringIO
+else: # pragma: no cover
+    from cStringIO import StringIO # pylint:disable=import-error
+
+_orig_append_description_of = BaseDescription.append_description_of
+def _append_description_of_map(self, value):
+    if not hasattr(value, 'describe_to'):
+        if isinstance(value, (Mapping, Sequence)):
+            sio = StringIO()
+            pprint.pprint(value, sio)
+            self.append(sio.getvalue())
+            return self
+    return _orig_append_description_of(self, value)
+
+BaseDescription.append_description_of = _append_description_of_map
+
+
+class TypeCheckedDict(dict):
+    """
+    A dictionary that ensures keys and values are of the required type when set
+    """
+
+    def __init__(self, key_class=object, val_class=object, notify=None):
+        dict.__init__(self)
+        self.key_class = key_class
+        self.val_class = val_class
+        self.notify = notify
+
+    def __setitem__(self, key, val):
+        assert_that(key, is_(self.key_class))
+        assert_that(val, is_(self.val_class))
+        dict.__setitem__(self, key, val)
+        if self.notify:
+            self.notify(key, val)

nti/testing/mock.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import sys
+
+# This module exists on disk to satisfy static linters;
+# it replaces itself when loaded.
+try:
+    from unittest import mock
+except ImportError: # pragma: no cover
+    # Python 2
+    import mock
+
+# More for static linters
+Mock = mock.Mock
+MagicMock = mock.MagicMock
+patch = mock.patch
+
+sys.modules[__name__] = mock

nti/testing/tests/test_base.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Tests for base.py.
+
+.. $Id$
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+# stdlib imports
+import unittest
+
+from nti.testing import base
+from nti.testing.matchers import has_attr
+
+from hamcrest import assert_that
+from hamcrest import is_
+
+__docformat__ = "restructuredtext en"
+
+logger = __import__('logging').getLogger(__name__)
+
+#disable: accessing protected members, too many methods
+#pylint: disable=W0212,R0904
+
+class TestBase(unittest.TestCase):
+
+    def test_package(self):
+        import nti.testing
+
+        class MyTest(base.AbstractTestBase):
+            pass
+
+        b = MyTest('get_configuration_package')
+        assert_that(b.get_configuration_package(),
+                    is_(nti.testing))
+
+    def test_cleanup(self):
+        called = [0]
+        def func():
+            called[0] += 1
+
+        base.addSharedCleanUp(func)
+        base.sharedCleanup()
+        assert_that(called[0], is_(1))
+
+        import zope.testing
+
+        zope.testing.cleanup.cleanUp()
+        assert_that(called[0], is_(2))
+
+        base._shared_cleanups.remove((func, (), {}))
+
+    def test_explicit_transaction_cleanup(self):
+        import transaction
+        import zope.testing
+        transaction.manager.explicit = True
+        transaction.begin()
+
+        zope.testing.cleanup.cleanUp()
+        assert_that(transaction.manager, has_attr('explicit', False))
+
+    def test_explicit_transaction_cleanup_no_transaction(self):
+        import transaction
+        import zope.testing
+        transaction.manager.explicit = True
+        zope.testing.cleanup.cleanUp()
+        assert_that(transaction.manager, has_attr('explicit', False))
+
+    def test_shared_test_base_cover(self):
+        # Just coverage.
+        import gc
+        class MyTest(base.AbstractSharedTestBase):
+            HANDLE_GC = True
+            def test_thing(self):
+                raise AssertionError("Not called")
+
+        MyTest.setUpClass()
+        # pylint:disable-next=simplifiable-if-expression
+        assert_that(gc.isenabled(), is_(False if not base._is_pypy else True))
+        MyTest.tearDownClass()
+        assert_that(gc.isenabled(), is_(True))
+
+        MyTest('test_thing').setUp()
+        MyTest('test_thing').tearDown()
+
+
+    def test_configuring_base(self):
+        import zope.traversing.tests.test_traverser
+        class MyTest(base.ConfiguringTestBase):
+            set_up_packages = ('zope.component',
+                               ('configure.zcml', 'zope.component'),
+                               zope.traversing.tests.test_traverser)
+
+            def test_thing(self):
+                raise AssertionError("Not called")
+
+        mt = MyTest('test_thing')
+        mt.setUp() # pylint:disable=no-value-for-parameter
+        mt.configure_string('<configure xmlns="http://namespaces.zope.org/zope" />')
+        mt.tearDown() # pylint:disable=no-value-for-parameter
+
+    def test_shared_configuring_base(self):
+        import zope.traversing.tests.test_traverser
+        class MyTest(base.SharedConfiguringTestBase):
+            layer = None # replaced by metaclass
+            set_up_packages = ('zope.component',
+                               ('configure.zcml', 'zope.component'),
+                               zope.traversing.tests.test_traverser)
+
+            def test_thing(self):
+                raise AssertionError("Not called")
+
+        MyTest.setUpClass()
+        MyTest.tearDownClass()
+
+        # It should have a layer automatically
+        assert_that(MyTest, has_attr('layer', has_attr('__name__', 'MyTest')))
+
+        MyTest.layer.setUp()
+        MyTest.layer.testSetUp()
+        MyTest.layer.testTearDown()
+        MyTest.layer.tearDown()
+
+        MyTest('test_thing').tearDown()
+
+    def test_module_setup(self):
+        base.module_setup()
+        base.module_setup(set_up_packages=('zope.component',))
+        base.module_teardown()
+
+    def test_calling_super_linting(self):
+        # Deriving a class from our bases and calling their setup
+        # methods should NOT produce linter warnings.
+        # So this section should not have pylint disable commands.
+        class X(base.AbstractTestBase):
+            def setUp(self):
+                super().setUp()
+                self.thing = 1
+
+            def tearDown(self):
+                super().tearDown()
+                self.thing = 2
+
+        class Y(base.ConfiguringTestBase):
+            def setUp(self):
+                super().setUp()
+                self.thing = 1
+
+            def tearDown(self):
+                super().tearDown()
+                self.thing = 2
+
+        X().setUp()
+        X().tearDown()
+        Y().setUp()
+        Y().tearDown()