nti.testing 4.2.0__py3-none-any.whl

nti/testing/tests/test_zodb.py

@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+"""
+Tests for zodb.py
+
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import io
+import gc
+import unittest
+
+import transaction
+from transaction.interfaces import NoTransaction
+from zope import interface
+from nti.testing import zodb
+
+# pylint:disable=protected-access,pointless-string-statement
+
+NativeStringIO = io.BytesIO if str is bytes else io.StringIO
+
+class MockDB(object):
+
+    def __init__(self):
+        self.pool = []
+
+    def open(self):
+        conn = MockConn()
+        self.pool.append(conn)
+        return conn
+
+
+class MockConn(object):
+    closed = False
+    minimized = False
+    def close(self):
+        self.closed = True
+
+    def cacheMinimize(self):
+        self.minimized = True
+
+
+class MockDBTrans(zodb.mock_db_trans):
+
+    def __init__(self, db=None):
+        if db is None:
+            db = MockDB()
+        super().__init__(db)
+        self.exc_file = NativeStringIO()
+
+class TestMockDBTrans(unittest.TestCase):
+
+    def setUp(self):
+        self._was_explicit = transaction.manager.explicit
+        transaction.manager.explicit = False
+
+    def tearDown(self):
+        transaction.manager.explicit = self._was_explicit
+        transaction.abort()
+
+    def test_begins_ends_transaction(self):
+        transaction.manager.explicit = True
+        with self.assertRaises(NoTransaction):
+            transaction.get()
+
+        with MockDBTrans():
+            self.assertIsNotNone(transaction.get())
+
+        transaction.manager.explicit = True
+        with self.assertRaises(NoTransaction):
+            transaction.get()
+
+    def test_sets_txm_explicit(self):
+        with MockDBTrans():
+            self.assertTrue(transaction.manager.explicit)
+        self.assertFalse(transaction.manager.explicit)
+
+    def test_error_if_mode_changed(self):
+        with self.assertRaises(zodb._TransactionManagerModeChanged):
+            with MockDBTrans():
+                transaction.manager.explicit = False
+
+    def test_error_if_mode_changed_and_error_in_body(self):
+        with self.assertRaises(zodb._TransactionManagerModeChanged) as exc:
+            with MockDBTrans():
+                transaction.manager.explicit = False
+                raise Exception("BodyError") # pylint:disable=broad-exception-raised
+        # The backing exception is included
+        self.assertIn('BodyError', str(exc.exception))
+
+    def test_error_if_tx_ended(self):
+        with self.assertRaises(zodb._TransactionChanged):
+            with MockDBTrans():
+                transaction.commit()
+
+    def test_error_if_tx_changed(self):
+        with self.assertRaises(zodb._TransactionChanged):
+            with MockDBTrans():
+                transaction.commit()
+                transaction.begin()
+
+    def test_error_if_tx_changed_aborts_new(self):
+        transaction.manager.explicit = True
+        with self.assertRaises(zodb._TransactionChanged):
+            with MockDBTrans():
+                transaction.commit()
+                transaction.begin()
+        with self.assertRaises(NoTransaction):
+            transaction.get()
+
+    def test_returns_connection_it_closes(self):
+        with MockDBTrans() as conn:
+            self.assertIsInstance(conn, MockConn)
+
+        self.assertTrue(conn.closed)
+        self.assertTrue(conn.minimized)
+
+    def test_aborts_doomed_tx(self):
+        aborted = []
+        with MockDBTrans():
+            transaction.doom()
+            tx = transaction.get()
+            abort = tx.abort
+
+            def _abort():
+                abort()
+                aborted.append(1)
+            tx.abort = _abort
+
+        self.assertEqual(aborted, [1])
+
+    def test_closing_conn_error_not_shadow_body_error(self):
+        class ConnEx(Exception):
+            pass
+
+        class BodyEx(Exception):
+            pass
+
+        def e():
+            raise ConnEx
+
+        mock_db_trans = MockDBTrans()
+        with self.assertRaises(BodyEx):
+            with mock_db_trans as conn:
+                conn.close = e
+                raise BodyEx
+
+        msg = mock_db_trans.exc_file.getvalue()
+        self.assertIn('Unexpected error closing connection', msg)
+        self.assertIn('Module nti.testing.zodb', msg)
+
+
+    def test_aborts_on_abort_error(self):
+        aborted = []
+        class AbortEx(Exception):
+            pass
+        with self.assertRaises(AbortEx):
+            with MockDBTrans():
+                transaction.doom()
+                tx = transaction.get()
+                abort = tx.abort
+
+                def _abort():
+                    abort()
+                    aborted.append(1)
+                    del tx.abort
+                    raise AbortEx
+                tx.abort = _abort
+
+        self.assertEqual(aborted, [1])
+
+    def test_aborts_on_commit_error(self):
+        committed = []
+        class CommitEx(Exception):
+            pass
+        with self.assertRaises(CommitEx):
+            with MockDBTrans():
+                tx = transaction.get()
+                commit = tx.commit
+
+                def _commit():
+                    commit()
+                    committed.append(1)
+                    del tx.commit
+                    raise CommitEx
+                tx.commit = _commit
+
+        self.assertEqual(committed, [1])
+
+    def test_abort_error_does_not_shadow_body_error(self):
+        aborted = []
+        class AbortEx(Exception):
+            pass
+        class BodyEx(Exception):
+            pass
+        mock_db_trans = MockDBTrans()
+        with self.assertRaises(BodyEx):
+            with mock_db_trans:
+                transaction.doom()
+                tx = transaction.get()
+                abort = tx.abort
+
+                def _abort():
+                    abort()
+                    aborted.append(1)
+                    del tx.abort
+                    raise AbortEx
+                tx.abort = _abort
+                raise BodyEx
+
+        self.assertEqual(aborted, [1])
+        msg = mock_db_trans.exc_file.getvalue()
+        self.assertIn('Failed to cleanup trans', msg)
+        self.assertIn('Module nti.testing.zodb', msg)
+
+    def test_error_in_on_opened(self):
+        class OpenEx(Exception):
+            pass
+
+        class MyFalse(object):
+            def __bool__(self):
+                return False
+
+        transaction.manager.explicit = MyFalse()
+        class MyMock(MockDBTrans):
+            seen_tx = None
+            aborted = False
+            def on_connection_opened(self, conn):
+                # pylint:disable=no-member
+                self.seen_tx = self._mock_db_trans__current_transaction
+                abort = self.seen_tx.abort
+                def _abort():
+                    abort()
+                    self.aborted = True
+                    del self.seen_tx.abort
+                self.seen_tx.abort = _abort
+                raise OpenEx
+
+        db = MockDB()
+        my_mock = MyMock(db)
+        with self.assertRaises(OpenEx):
+            with my_mock:
+                "We never get here"
+
+        # The txm mode was restored
+        self.assertFalse(transaction.manager.explicit)
+        self.assertIsInstance(transaction.manager.explicit, MyFalse)
+        # the conn was opened, and then closed
+        self.assertTrue(db.pool[0].closed)
+        self.assertIsNone(my_mock.conn)
+        # The transaction that was opened is cleaned up
+        self.assertTrue(my_mock.aborted)
+
+
+class TestZODBLayer(unittest.TestCase):
+
+    layer = zodb.ZODBLayer
+
+    def test_registration(self):
+        from ZODB.interfaces import IDatabase
+        from zope import component
+        gsm = component.getGlobalSiteManager()
+        reg_db = gsm.getUtility(IDatabase)
+        self.assertIsNotNone(reg_db)
+        self.assertIs(reg_db, self.layer.db)
+
+    def test_premature_teardown(self):
+        self.layer.tearDown()
+        from ZODB.interfaces import IDatabase
+        from zope import component
+        gsm = component.getGlobalSiteManager()
+        reg_db = gsm.queryUtility(IDatabase)
+        self.assertIsNone(reg_db)
+
+        self.layer.setUp()
+
+
+class IExtra(interface.Interface): # pylint:disable=inherit-non-class
+    """An extra interface."""
+
+class IExtra2(interface.Interface): # pylint:disable=inherit-non-class
+    """Another extra interface."""
+
+class Object(object):
+
+    def __init__(self, *args):
+        pass
+
+class TestResetDbCaches(unittest.TestCase):
+    layer = zodb.ZODBLayer
+
+    def setUp(self):
+        super().setUp()
+        gc.disable()
+
+    def tearDown(self):
+        gc.enable()
+        super().tearDown()
+
+    def test_persistent_site_closed(self):
+        from zope.site.site import LocalSiteManager
+        from ZODB import DB
+        from ZODB.DemoStorage import DemoStorage
+
+        interface.classImplements(LocalSiteManager, IExtra)
+
+        db = DB(DemoStorage())
+        transaction.begin()
+        conn = db.open()
+        site_man = LocalSiteManager(None)
+        conn.root()[0] = site_man
+        site_man.registerAdapter(Object, [IExtra], IExtra2)
+        site_man.getAdapter(LocalSiteManager(None), IExtra2)
+        transaction.commit()
+        conn.close()
+
+        zodb.reset_db_caches(db)
+        IExtra.changed(None) # pylint:disable=no-value-for-parameter
+
+    def test_arguments(self):
+        # Don't pass the DB, let it get the one from the layer.
+        # But do ask for collect, so we get something non-negative on
+        # all platforms.
+        collected = zodb.reset_db_caches(collect=True)
+        self.assertNotEqual(collected, -1)

nti/testing/time.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Test support for working with clocks and time.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+# stdlib imports
+import functools
+from threading import Lock
+import time
+from time import time as _real_time
+from time import gmtime as _real_gmtime
+
+import six
+
+from nti.testing.mock import Mock
+
+__docformat__ = "restructuredtext en"
+
+_current_time = _real_time()
+
+
+class _TimeWrapper(object):
+
+    def __init__(self, granularity=1.0):
+        self._granularity = granularity
+        self._lock = Lock()
+        self.fake_gmtime = Mock()
+        self.fake_time = Mock()
+        self._configure_fakes()
+
+    def _configure_fakes(self):
+        def incr():
+            global _current_time # pylint:disable=global-statement
+            with self._lock:
+                _current_time = max(_real_time(), _current_time + self._granularity)
+            return _current_time
+        self.fake_time.side_effect = incr
+
+        def incr_gmtime(*seconds):
+            if seconds:
+                assert len(seconds) == 1
+                now = seconds[0]
+            else:
+                now = incr()
+            return _real_gmtime(now)
+        self.fake_gmtime.side_effect = incr_gmtime
+
+    def install_fakes(self):
+        time.time = self.fake_time
+        time.gmtime = self.fake_gmtime
+
+    __enter__ = install_fakes
+
+    def close(self, *_args):
+        time.time = _real_time
+        time.gmtime = _real_gmtime
+
+    __exit__ = close
+
+    def __call__(self, func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            with self:
+                return func(*args, **kwargs)
+        return wrapper
+
+
+
+def time_monotonically_increases(func_or_granularity):
+    """
+    Decorate a unittest method with this function to cause the value
+    of :func:`time.time` (and :func:`time.gmtime`) to monotonically
+    increase by one each time it is called. This ensures things like
+    last modified dates always increase.
+
+    We make three guarantees about the value of :func:`time.time`
+    returned while the decorated function is running:
+
+        1. It is always *at least* the value of the *real*
+           :func:`time.time`;
+
+        2. Each call returns a value greater than the previous call;
+
+        3. Those two constraints hold across different invocations of
+           functions decorated.
+
+    This decorator can be applied to a method in a test case::
+
+        class TestThing(unittest.TestCase)
+            @time_monotonically_increases
+            def test_method(self):
+              t = time.time()
+               ...
+
+    It can also be applied to a bare function taking any number of
+    arguments::
+
+        @time_monotonically_increases
+        def utility_function(a, b, c=1):
+           t = time.time()
+           ...
+
+    By default, the time will be incremented in 1.0 second intervals.
+    You can specify a particular granularity as an argument; this is
+    useful to keep from running too far ahead of the real clock::
+
+        @time_monotonically_increases(0.1)
+        def smaller_increment():
+            t1 = time.time()
+            t2 = time.time()
+            assrt t2 == t1 + 0.1
+
+    .. seealso:: `nti.testing.time.reset_monotonic_time`
+
+    .. versionchanged:: 2.1
+       Add support for ``time.gmtime``.
+    .. versionchanged:: 2.1
+       Now thread safe.
+    .. versionchanged:: 2.0
+       The decorated function returns whatever the passed function returns.
+    .. versionchanged:: 2.0
+       Properly handle more than one argument to the underlying function.
+    .. versionchanged:: 2.0
+       Ensure that the values returned are at least the real time. Previously
+       they were integers starting at 0.
+    .. versionchanged:: 2.0
+       Ensure that the values returned are increasing even across different
+       invocations of a decorated function or different decorated functions. Previously
+       different functions would return the same sequence.
+    .. versionchanged:: 2.0
+       Allow specifying the granularity of clock increments. Keep at
+       1.0 seconds for backwards compatibility by default.
+    """
+    if isinstance(func_or_granularity, (six.integer_types, float)):
+        # We're being used as a factory.
+        wrapper_factory = _TimeWrapper(func_or_granularity)
+        return wrapper_factory
+
+    # We're being used bare
+    wrapper_factory = _TimeWrapper()
+    return wrapper_factory(func_or_granularity)
+
+
+def reset_monotonic_time(value=0.0):
+    """
+    Make the monotonic clock return the real time on its next
+    call.
+
+    .. versionadded:: 2.0
+    """
+
+    global _current_time # pylint:disable=global-statement
+    _current_time = value
+
+
+class MonotonicallyIncreasingTimeLayerMixin(object):
+    """
+    A helper for layers that need time to increase monotonically.
+
+    You can either mix this in to a layer object, or instantiate it
+    and call the methods directly.
+
+    .. versionadded:: 2.2
+    """
+
+    def __init__(self, granularity=1.0):
+        self.time_manager = _TimeWrapper(granularity)
+
+    def testSetUp(self):
+        self.time_manager.install_fakes()
+
+    def testTearDown(self):
+        self.time_manager.close()
+        reset_monotonic_time()