nti.testing 4.2.0__py3-none-any.whl

nti/testing/tests/test_component_cleanup_broken.txt

@@ -0,0 +1,137 @@
+When zope.component.hooks is loaded, it installs a zope.testing
+cleanup function. However, prior to version 4.2.0, this cleanup
+function isn't adequote and leaves stale data around, leading
+zope.interface adapters to improperly adapt things (a particular
+problem when running test suites that load different adapter
+configurations) This problem goes away if zope.site.site is imported
+and installs its cleanup hooks.
+
+Although the bug has been fixed, it was an interesting problem, and
+this file remains to provide an example of working with ZCA internals.
+Tests that are now fixed are marked as skipped.
+
+Demonstration
+=============
+
+We can demonstrate this with some code.
+
+First we import the basic modules::
+
+	>>> from zope.testing import cleanup
+	>>> from zope import interface
+	>>> from zope import component
+	>>> from zope.component import hooks
+
+Next, we define an interface and two different adapters::
+
+	>>> class II(interface.Interface): pass
+	>>> class O(object): pass
+	>>> class A1(object):
+	...    def __init__( self, *args):
+	...        pass
+	...    def __repr__( self ):
+	...       return "<A1>"
+	>>> class A2(object):
+	...    def __init__( self, *args):
+	...        pass
+	...    def __repr__( self ):
+	...        return "<A2>"
+
+We can now proceed to run our "unit tests". Each of these unit tests
+will begin by installing the component hooks and providing some base
+configuration in the form of registering the A1 adapter::
+
+	>>> hooks.setHooks()
+	>>> component.provideAdapter( A1, adapts=(O,), provides=II )
+
+If we do nothing further, we can get get back the A1 adapter when we
+ask for it from both zope.component, and thanks to the adapter hook, zope.interface::
+
+	>>> component.getAdapter( O(), II )
+	<A1>
+	>>> II( O() )
+	<A1>
+
+Lets suppose some tests start with the base configuration and override
+it, installing the second adapter::
+
+	>>> component.provideAdapter( A2, adapts=(O,), provides=II )
+
+This adapter can now be accessed in both of those places::
+
+	>>> component.getAdapter( O(), II )
+	<A2>
+	>>> II( O() )
+	<A2>
+
+Finally, our test case shuts down and the cleanup is run::
+
+	>>> cleanup.cleanUp()
+
+To demonstrate the problem, let's begin the next test case run with the
+same basic setup as before:::
+
+	>>> hooks.setHooks()
+	>>> component.provideAdapter( A1, adapts=(O,), provides=II )
+
+At this point, we would expect to get back A1 when we ask for
+adapters. If we ask the global site manager directly for it, we're
+alright::
+
+	>>> component.getGlobalSiteManager().queryAdapter( O(), II )
+	<A1>
+
+But if we ask the (hooked) global API, we have a problem::
+
+	>>> component.queryAdapter( O(), II )  # doctest: +SKIP
+	<A2>
+
+And we have the same problem if we ask zope.interface::
+
+	>>> II( O() )  # doctest: +SKIP
+	<A2>
+
+You can see that we get back the A2 registration, which should no
+longer be here, as the cleanup hooks have run. zope.interface's
+cleanup hooks reset the entire global registry, in fact, by re-running
+its __init__ method. What's causing this?
+
+A clue comes in the form of realizing that this doesn't happen all the
+time. In fact, as soon as zope.site.site is imported, it no longer
+happens at all::
+
+	>>> from zope.site import site
+
+zope.site.site installs a cleanup function that calls
+zope.component.hooks.setSite to clear the site::
+
+	>>> cleanup.cleanUp()
+
+Now the next time a test runs, the ancient A2 registration is truly gone::
+
+	>>> hooks.setHooks()
+	>>> component.provideAdapter( A1, adapts=(O,), provides=II )
+
+both from zope.component::
+
+	>>> component.queryAdapter( O(), II )
+	<A1>
+
+and zope.interface::
+
+	>>> II( O() )
+	<A1>
+
+Analysis
+========
+
+In a nutshell, what appears to be happening is that
+zope.component.hooks.SiteInfo caches the adapter_hook of the current
+site manager's `adapters` property the first time it is accessed.
+However, the cleanup for the globalSiteManager completely *replaces*
+its `adapters` property with a new object, leaving SiteInfo holding a
+dangling reference to an adapter registry that is no longer installed
+anywhere. Importing zope.site.site causes the
+zope.component.hooks.setSite to be called to clear out the site, which
+causes the cached adapter_hook to be deleted, thus letting it get a
+new reference to the current adapter registry.

nti/testing/tests/test_layers.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Test for layers.py.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+# stdlib imports
+import unittest
+
+from nti.testing import layers
+
+from hamcrest import assert_that
+from hamcrest import is_
+
+__docformat__ = "restructuredtext en"
+
+
+class TestLayers(unittest.TestCase):
+
+    def test_find_test(self):
+
+        def func():
+            assert_that(layers.find_test(), is_(self))
+
+        func()
+
+        def via_test(test): # pylint:disable=unused-argument
+            func()
+
+        via_test(self)
+
+    def _check_methods(self, layer, extra_methods=()):
+        default_methods = ('setUp', 'tearDown', 'testSetUp', 'testTearDown')
+        for meth in default_methods + extra_methods:
+            getattr(layer, meth)()
+
+    def test_gc(self):
+
+        gcm = layers.GCLayerMixin()
+        self._check_methods(gcm, ('setUpGC', 'tearDownGC'))
+
+    def test_shared_cleanup(self):
+        self._check_methods(layers.SharedCleanupLayer)
+
+    def test_zcl(self):
+        self._check_methods(layers.ZopeComponentLayer)
+
+    def test_configuring_layer_mixin(self):
+        class Layer(layers.ConfiguringLayerMixin):
+            set_up_packages = ('zope.component',)
+
+        self._check_methods(Layer, ('setUpPackages', 'tearDownPackages'))

nti/testing/tests/test_main.py

@@ -0,0 +1,47 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+# stdlib imports
+import doctest
+import os
+import unittest
+
+
+class TestImport(unittest.TestCase):
+    def test_import(self):
+        for name in ('base', 'layers', 'matchers', 'time'):
+            __import__('nti.testing.' + name)
+
+    def test_mock_direct_import(self):
+        from nti.testing.mock import Mock
+        from nti.testing import mock
+        self.assertIs(mock.Mock, Mock)
+
+    def test_mock_module_identity(self):
+        from nti.testing import mock
+        try:
+            from unittest import mock as stdmock
+        except ImportError: # pragma: no cover
+            # Python 2
+            import mock as stdmock
+
+        self.assertIs(mock, stdmock)
+
+def test_suite():
+    here = os.path.dirname(__file__)
+
+    suite = unittest.defaultTestLoader.loadTestsFromName(__name__)
+    suite.addTest(doctest.DocFileSuite(
+        'test_component_cleanup_broken.txt'))
+
+    readmedir = here
+    while not os.path.exists(os.path.join(readmedir, 'setup.py')):
+        readmedir = os.path.dirname(readmedir)
+    readme = os.path.join(readmedir, 'README.rst')
+    suite.addTest(doctest.DocFileSuite(
+        readme,
+        module_relative=False,
+        optionflags=doctest.ELLIPSIS,
+    ))
+    return suite

nti/testing/tests/test_matchers.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Tests for matchers.py.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+# stdlib imports
+import unittest
+
+from hamcrest import assert_that
+from hamcrest import calling
+
+from hamcrest import raises
+
+from nti.testing import matchers
+
+__docformat__ = "restructuredtext en"
+
+
+# pylint:disable=inherit-non-class,redundant-u-string-prefix
+
+
+class TestMatchers(unittest.TestCase):
+
+    def test_bool(self):
+        assert_that(True, matchers.is_true())
+        assert_that(1, matchers.is_true())
+
+        assert_that(False, matchers.is_false())
+        assert_that(0, matchers.is_false())
+
+
+        assert_that(calling(assert_that).with_args(1, matchers.is_false()),
+                    raises(AssertionError))
+
+        assert_that(calling(assert_that).with_args(u'', matchers.is_true()),
+                    raises(AssertionError))
+        assert_that(calling(assert_that).with_args(b'', matchers.is_true()),
+                    raises(AssertionError))
+
+    def test_provides(self):
+
+        from zope import interface
+
+        class IThing(interface.Interface):
+            pass
+
+        @interface.implementer(IThing)
+        class Thing(object):
+            pass
+
+        assert_that(Thing(), matchers.provides(IThing))
+        assert_that(calling(assert_that).with_args(self, matchers.provides(IThing)),
+                    raises(AssertionError, "object providing"))
+
+    def test_implements(self):
+
+        from zope import interface
+
+        class IThing(interface.Interface):
+            pass
+
+        @interface.implementer(IThing)
+        class Thing(object):
+            pass
+
+        assert_that(Thing, matchers.implements(IThing))
+        assert_that(calling(assert_that).with_args(self, matchers.implements(IThing)),
+                    raises(AssertionError, "object implementing"))
+
+
+    def test_verifiably_provides(self):
+
+        from zope import interface
+
+        class IThing(interface.Interface):
+            thing = interface.Attribute("thing")
+
+            def method(): # pylint:disable=no-method-argument
+                """Does nothing."""
+
+        @interface.implementer(IThing)
+        class Thing(object):
+            thing = 1
+
+            def method(self):
+                raise AssertionError("Not called")
+
+        assert_that(Thing(), matchers.verifiably_provides(IThing, IThing))
+        # We have a nice multi-line error message, but we can only match one line at a time
+        for line in (
+                'verifiably providing .*IThing',
+                'Using class.*has failed to implement',
+                'Does not declaratively implement',
+                'thing attribute was not provided',
+                r'method\(\) attribute was not provided',
+        ):
+            assert_that(calling(assert_that).with_args(self, matchers.verifiably_provides(IThing)),
+                        raises(AssertionError, line))
+
+        broken_thing = Thing()
+        broken_thing.method = None
+        assert_that(calling(assert_that).with_args(broken_thing,
+                                                   matchers.verifiably_provides(IThing)),
+                    raises(AssertionError, r"The contract of.*method\(\) is violated"))
+
+        del Thing.thing
+        assert_that(calling(assert_that).with_args(Thing(), matchers.verifiably_provides(IThing)),
+                    raises(AssertionError, "thing attribute was not provided"))
+
+    def test_validly_provides(self):
+
+        from zope import interface
+        from zope.schema import Int
+
+        class IThing(interface.Interface):
+            thing = Int()
+
+        @interface.implementer(IThing)
+        class Thing(object):
+            thing = 1
+
+        assert_that(Thing(), matchers.validly_provides(IThing, IThing))
+        # We have a nice multi-line error message, but we can only match one line at a time
+        for line in (
+                'verifiably providing .*IThing.*validly providing.*IThing',
+                'Using class.*has failed to implement',
+                'Does not declaratively implement',
+                'thing attribute was not provided'
+        ):
+            assert_that(calling(assert_that).with_args(self, matchers.validly_provides(IThing)),
+                        raises(AssertionError, line))
+
+        broken_thing = Thing()
+        broken_thing.thing = "not an int"
+
+        assert_that(calling(assert_that).with_args(broken_thing, matchers.validly_provides(IThing)),
+                    raises(AssertionError, "has attribute"))
+
+    def test_validated_by(self):
+        from zope.schema import Int
+        from zope.schema.interfaces import WrongType
+
+        assert_that(1, matchers.validated_by(Int()))
+        assert_that('', matchers.not_validated_by(Int()))
+        with self.assertRaises(WrongType):
+            assert_that('', matchers.not_validated_by(Int(), invalid=NameError))
+        assert_that(calling(assert_that).with_args('', matchers.validated_by(Int())),
+                    raises(AssertionError, "failed to validate"))
+
+    def test_validated_by_defaults_to_Invalid(self):
+        from zope.interface.exceptions import Invalid
+        class Validator(object):
+            def validate(self, o):
+                raise o
+
+        validator = Validator()
+        class Arbitrary(Exception):
+            pass
+
+        with self.assertRaises(Arbitrary):
+            assert_that(Arbitrary(), matchers.validated_by(validator))
+
+        assert_that(calling(assert_that).with_args(Invalid(),
+                                                   matchers.validated_by(validator)),
+                    raises(AssertionError, "failed to validate"))
+
+        assert_that(calling(assert_that).with_args(Arbitrary,
+                                                   matchers.validated_by(validator,
+                                                                         invalid=Exception)),
+                    raises(AssertionError, "failed to validate"))
+
+
+    def test_dict(self):
+
+        d = matchers.TypeCheckedDict(key_class=int, notify=lambda k, v: None)
+
+        d[1] = 'abc'
+
+        assert_that(calling(d.__setitem__).with_args('abc', 'def'),
+                    raises(AssertionError, "instance of int"))
+
+    def test_in_context(self):
+        # pylint:disable=attribute-defined-outside-init
+        class Thing(object):
+            def __init__(self, name, parent=None):
+                self.__name__ = name
+                if parent:
+                    self.__parent__ = parent
+            def __repr__(self):
+                return '<Thing %s>' % (self.__name__,)
+
+        parent = Thing('parent')
+        child = Thing('child', parent)
+        sibling = Thing('sibling', parent)
+
+        assert_that(child, matchers.aq_inContextOf(parent))
+
+        with self.assertRaises(AssertionError) as exc:
+            assert_that(parent, matchers.aq_inContextOf('ROOT'))
+        ex = str(exc.exception)
+        del exc
+        self.assertIn('object in context of', ex)
+        self.assertIn('<Thing parent> was not in the context of \'ROOT\'\n; its lineage is []', ex)
+
+        with self.assertRaises(AssertionError) as exc:
+            assert_that(sibling, matchers.aq_inContextOf(child))
+        ex = str(exc.exception)
+        del exc
+        self.assertIn('object in context of', ex)
+        self.assertIn('<Thing sibling> was not in the context of <Thing child>', ex)
+        self.assertIn('its lineage is [<Thing parent>]', ex)
+
+
+        # fake wrapper
+        child.aq_inContextOf = lambda thing: thing == child.__parent__
+        assert_that(child, matchers.aq_inContextOf(parent))
+
+    def test_in_context_no_Acquisition(self):
+        # pylint:disable=protected-access
+        orig_in_context = matchers._aq_inContextOf
+        matchers._aq_inContextOf = matchers._aq_inContextOf_NotImplemented
+        try:
+            with self.assertRaises(AssertionError) as exc:
+                assert_that(self, matchers.aq_inContextOf(self))
+
+        finally:
+            matchers._aq_inContextOf = orig_in_context
+
+        ex = str(exc.exception)
+        del exc
+        self.assertIn('object in context of', ex)
+        self.assertIn('Acquisition was not installed', ex)

nti/testing/tests/test_time.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+# stdlib imports
+import unittest
+
+from nti.testing.time import reset_monotonic_time
+from nti.testing.time import time_monotonically_increases
+
+from hamcrest import assert_that
+from hamcrest import greater_than
+from hamcrest import greater_than_or_equal_to
+from hamcrest import is_
+from hamcrest import less_than
+
+__docformat__ = "restructuredtext en"
+
+class TestTime(unittest.TestCase):
+
+    def _check_time(self, granularity=1.0):
+        import time
+        for _ in range(10):
+            before = time.time()
+            after = time.time()
+            assert_that(after, is_(greater_than_or_equal_to(before + granularity)))
+
+
+            assert_that(time.gmtime(after), is_(time.gmtime(after)))
+            assert_that(time.gmtime(after), is_(greater_than_or_equal_to(time.gmtime(before))))
+
+            if granularity >= 1.0:
+                gm_before = time.gmtime()
+                gm_after = time.gmtime()
+                assert_that(gm_after, is_(greater_than(gm_before)))
+        return after
+
+    @time_monotonically_increases
+    def test_increases_in_method(self):
+        self._check_time()
+
+    def test_increases_in_func(self):
+
+        @time_monotonically_increases
+        def f():
+            self._check_time()
+
+        f()
+
+    def test_func_takes_args(self):
+
+        @time_monotonically_increases
+        def f(a, b, c=42):
+            return a, b, c
+
+        assert_that(f(1, 2), is_((1, 2, 42)))
+        assert_that(f(1, 2, 3), is_((1, 2, 3)))
+        assert_that(f(1, 2, c=9), is_((1, 2, 9)))
+
+    def test_increases_relative_to_real(self):
+        import time
+        before_all = time.time()
+
+        @time_monotonically_increases
+        def f():
+            return self._check_time()
+
+        after_first = f()
+        assert_that(after_first, is_(greater_than(before_all)))
+
+
+    def test_increases_across_funcs(self):
+        reset_monotonic_time()
+
+        granularity = 0.1
+        import time
+        before_all = time.time()
+
+
+        @time_monotonically_increases(granularity)
+        def f1():
+            return self._check_time(granularity)
+
+        @time_monotonically_increases(granularity)
+        def f2():
+            return self._check_time(granularity)
+
+        @time_monotonically_increases(granularity)
+        def f3():
+            return time.time()
+
+        self._check_across_funcs(before_all, f1, f2, f3)
+
+    def _check_across_funcs(self, before_all, f1, f2, f3):
+        from nti.testing.time import _real_time
+        after_first = f1()
+
+        assert_that(after_first, is_(greater_than(before_all)))
+
+        after_second = f2()
+        current_real = _real_time()
+
+        # The loop in self._check_time incremented the clock by a full second.
+        # That function should have taken far less time to actually run than that, though,
+        # so the real time function should be *behind*
+        assert_that(current_real, is_(less_than(after_second)))
+
+
+        # And immediately running it again will continue to produce values that
+        # are ever larger.
+        after_second = f2()
+        current_real = _real_time()
+
+        assert_that(current_real, is_(less_than(after_second)))
+
+        assert_that(after_second, is_(greater_than(before_all)))
+        assert_that(after_second, is_(greater_than(after_first)))
+
+        # We are now some number of seconds ahead. If we're the only ones calling
+        # time.time(), it would be about 3. But we're not, various parts of the lib
+        # apparently are calling time.time() too, which makes it unpredictable.
+        # We don't want to sleep for a long time, so we
+        # reset the clock again to prove that we can go back to real time.
+
+        # Use a value in the distant past to account for the calls that get made.
+        reset_monotonic_time(-50)
+
+        after_third = f3()
+        current_real = _real_time()
+        assert_that(current_real, is_(greater_than_or_equal_to(after_third)))
+
+
+    def test_layer(self):
+        from nti.testing.time import MonotonicallyIncreasingTimeLayerMixin
+        import time
+        granularity = 0.1
+
+        def f1():
+            return self._check_time(granularity)
+
+        def f2():
+            return self._check_time(granularity)
+
+        def f3():
+            return time.time()
+
+        before_all = time.time()
+
+        layer = MonotonicallyIncreasingTimeLayerMixin(granularity)
+        layer.testSetUp()
+        try:
+            self._check_across_funcs(before_all, f1, f2, f3)
+        finally:
+            layer.testTearDown()