4696882551

Build Type

push

github

Committed by Michael Howitz

Commit Message

Preparing release 6.0

Run Details

460 of 475 branches covered (96.84%)

Branch coverage included in aggregate %.

4646 of 4646 relevant lines covered (100.0%)

1.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.42

/src/zope/component/tests/test_persistentregistry.py

##############################################################################
#
# Copyright (c) 2012 Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Tests for z.c.hooks
"""
import unittest

from zope.interface.tests.test_adapter import \
    CustomTypesBaseAdapterRegistryTests


def skipIfNoPersistent(testfunc):
    try:
        import persistent  # noqa: F401 imported but unused
    except ImportError:  # pragma: no cover
        return unittest.skip("persistent not installed")(testfunc)
    return testfunc


@skipIfNoPersistent
class PersistentAdapterRegistryTests(unittest.TestCase):

    def _getTargetClass(self):
        from zope.component.persistentregistry import PersistentAdapterRegistry
        return PersistentAdapterRegistry

    def _makeOne(self, *args, **kw):
        return self._getTargetClass()(*args, **kw)

    def _makeCache(self, jar):
        # Borrowed from persistent.tests.test_pyPersistence.

        class _Cache:
            def __init__(self, jar):
                self._jar = jar
                self._mru = []
                # mru(oid) is only called in pure-Python runs
                self.mru = self._mru.append

            def new_ghost(self, oid, obj):
                obj._p_jar = self._jar
                obj._p_oid = oid

            def update_object_size_estimation(self, oid, size):
                "This is only called in pure-Python runs"

        return _Cache(jar)

    def _makeJar(self):
        # Borrowed from persistent.tests.test_pyPersistence.
        from persistent.interfaces import IPersistentDataManager
        from zope.interface import implementer

        @implementer(IPersistentDataManager)
        class _Jar:
            def __init__(self):
                self._loaded = []
                self._registered = []

            def setstate(self, obj):
                self._loaded.append(obj._p_oid)

            def register(self, obj):
                self._registered.append(obj._p_oid)

        jar = _Jar()
        jar._cache = self._makeCache(jar)
        return jar

    def _makeOneWithJar(self, dirty=False, **kw):
        # Borrowed from persistent.tests.test_pyPersistence.
        OID = _makeOctets('\x01' * 8)
        inst = self._makeOne(**kw)
        jar = self._makeJar()
        jar._cache.new_ghost(OID, inst)  # assigns _p_jar, _p_oid
        return inst, jar, OID

    def test_changed_original_is_not_us(self):
        registry, jar, OID = self._makeOneWithJar()
        self.assertEqual(registry._generation, 1)
        registry.changed(object())
        # 'originally_changed' is not us, but we are still dirty because
        # '_generation' gets bumped.
        self.assertEqual(registry._p_changed, True)
        # base class gets called
        self.assertEqual(registry._generation, 2)

    def test_changed_original_is_us(self):
        registry, jar, OID = self._makeOneWithJar()
        self.assertEqual(registry._generation, 1)
        registry.changed(registry)
        # 'originally_changed' is not us, so not dirty
        self.assertEqual(registry._p_changed, True)
        # base class gets called
        self.assertEqual(registry._generation, 2)

    def test___getstate___simple(self):
        from zope.component import globalSiteManager
        bases = (globalSiteManager.adapters, globalSiteManager.utilities)
        registry, jar, OID = self._makeOneWithJar(bases=bases)
        state = registry.__getstate__()
        self.assertEqual(state.pop('__bases__'), bases)
        self.assertEqual(state.pop('_generation'), 1)
        self.assertEqual(state.pop('_provided'), {})
        self.assertEqual(state.pop('_adapters'), [])
        self.assertEqual(state.pop('_subscribers'), [])
        self.assertNotIn('ro', state)
        self.assertEqual(state, {})

    def test___getstate___skips_delegated_names(self):
        registry, jar, OID = self._makeOneWithJar()
        registry.names = lambda *args: ['a', 'b', 'c']
        self.assertFalse('names' in registry.__getstate__())

    def test___setstate___rebuilds__v_lookup(self):
        registry, jar, OID = self._makeOneWithJar()
        state = registry.__getstate__()
        self.assertTrue('_v_lookup' in registry.__dict__)
        registry._p_changed = None  # clears volatile '_v_lookup'
        self.assertFalse('_v_lookup' in registry.__dict__)
        registry.__setstate__(state)
        self.assertTrue('_v_lookup' in registry.__dict__)

    def test___setstate___rebuilds__ro(self):
        from zope.component import globalSiteManager
        bases = (globalSiteManager.adapters, globalSiteManager.utilities)
        registry, jar, OID = self._makeOneWithJar(bases=bases)
        state = registry.__getstate__()
        registry.__setstate__(state)
        self.assertEqual(registry.__bases__, bases)
        self.assertEqual(registry.ro, [registry] + list(bases))

    def test__addValueToLeaf_existing_is_tuple_converts(self):
        from persistent.list import PersistentList
        registry = self._makeOne()
        # It converts when the tuple is not empty...
        result = registry._addValueToLeaf(('a',), 'b')
        self.assertIsInstance(result, PersistentList)
        self.assertEqual(result, ['a', 'b'])
        # ...and when it is empty...
        result = registry._addValueToLeaf((), 'b')
        self.assertIsInstance(result, PersistentList)
        self.assertEqual(result, ['b'])
        # ...and in fact when it is even missing
        result = registry._addValueToLeaf(None, 'b')
        self.assertIsInstance(result, PersistentList)
        self.assertEqual(result, ['b'])

    def test__removeValueFromLeaf_existing_is_tuple_converts(self):
        from persistent.list import PersistentList
        registry = self._makeOne()
        # It converts when the item is found...
        result = registry._removeValueFromLeaf(('a', 'b'), 'b')
        self.assertIsInstance(result, PersistentList)
        self.assertEqual(result, ['a'])
        # ...and when it is not found
        result = registry._removeValueFromLeaf(('a',), 'b')
        self.assertIsInstance(result, PersistentList)
        self.assertEqual(result, ['a'])

    def test__addValueFromLeaf_preserves_identity(self):
        registry = self._makeOne()
        first = registry._addValueToLeaf(None, 'a')
        second = registry._addValueToLeaf(first, 'b')
        self.assertIs(first, second)
        self.assertEqual(second, ['a', 'b'])

    def test__removeValueFromLeaf_preserves_identity(self):
        registry = self._makeOne()
        first = registry._addValueToLeaf(None, 'a')
        second = registry._addValueToLeaf(first, 'b')
        third = registry._addValueToLeaf(second, 'c')
        fourth = registry._removeValueFromLeaf(third, 'c')
        self.assertIs(first, second)
        self.assertIs(third, fourth)
        self.assertIs(first, fourth)
        self.assertEqual(fourth, ['a', 'b'])


@skipIfNoPersistent
class PersistentComponentsTests(unittest.TestCase):

    def _getTargetClass(self):
        from zope.component.persistentregistry import PersistentComponents
        return PersistentComponents

    def _makeOne(self, *args, **kw):
        return self._getTargetClass()(*args, **kw)

    def test_ctor_initializes_registries_and_registrations(self):
        from persistent.list import PersistentList
        from persistent.mapping import PersistentMapping

        from zope.component.persistentregistry import PersistentAdapterRegistry
        registry = self._makeOne()
        self.assertTrue(isinstance(registry.adapters,
                                   PersistentAdapterRegistry))
        self.assertTrue(isinstance(registry.utilities,
                                   PersistentAdapterRegistry))
        self.assertTrue(isinstance(registry._adapter_registrations,
                                   PersistentMapping))
        self.assertTrue(isinstance(registry._utility_registrations,
                                   PersistentMapping))
        self.assertTrue(isinstance(registry._subscription_registrations,
                                   PersistentList))
        self.assertTrue(isinstance(registry._handler_registrations,
                                   PersistentList))


def _makeOctets(s):
    return bytes(s) if bytes is str else bytes(s, 'ascii')


@skipIfNoPersistent
class PersistentAdapterRegistryCustomTypesTest(
        CustomTypesBaseAdapterRegistryTests):

    def _getMappingType(self):
        from persistent.mapping import PersistentMapping
        return PersistentMapping

    def _getProvidedType(self):
        return self._getMappingType()

    def _getMutableListType(self):
        from persistent.list import PersistentList
        return PersistentList

    def _getLeafSequenceType(self):
        return self._getMutableListType()

    def _getBaseAdapterRegistry(self):
        from zope.component.persistentregistry import PersistentAdapterRegistry
        return PersistentAdapterRegistry

1	##############################################################################
2	#
3	# Copyright (c) 2012 Zope Foundation and Contributors.
4	# All Rights Reserved.
5	#
6	# This software is subject to the provisions of the Zope Public License,
7	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
8	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
9	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
11	# FOR A PARTICULAR PURPOSE.
12	#
13	##############################################################################
14	"""Tests for z.c.hooks	1✔
15	"""
16	import unittest	1✔
17
18	from zope.interface.tests.test_adapter import \	1✔
19	CustomTypesBaseAdapterRegistryTests
20
21
22	def skipIfNoPersistent(testfunc):	1✔
23	try:	1✔
24	import persistent # noqa: F401 imported but unused	1✔
25	except ImportError: # pragma: no cover
26	return unittest.skip("persistent not installed")(testfunc)
27	return testfunc	1✔
28
29
30	@skipIfNoPersistent	1✔
31	class PersistentAdapterRegistryTests(unittest.TestCase):	1✔
32
33	def _getTargetClass(self):	1✔
34	from zope.component.persistentregistry import PersistentAdapterRegistry	1✔
35	return PersistentAdapterRegistry	1✔
36
37	def _makeOne(self, args, *kw):	1✔
38	return self._getTargetClass()(args, *kw)	1✔
39
40	def _makeCache(self, jar):	1✔
41	# Borrowed from persistent.tests.test_pyPersistence.
42
43	class _Cache:	1✔
44	def __init__(self, jar):	1✔
45	self._jar = jar	1✔
46	self._mru = []	1✔
47	# mru(oid) is only called in pure-Python runs
48	self.mru = self._mru.append	1✔
49
50	def new_ghost(self, oid, obj):	1✔
51	obj._p_jar = self._jar	1✔
52	obj._p_oid = oid	1✔
53
54	def update_object_size_estimation(self, oid, size):	1✔
55	"This is only called in pure-Python runs"
56
57	return _Cache(jar)	1✔
58
59	def _makeJar(self):	1✔
60	# Borrowed from persistent.tests.test_pyPersistence.
61	from persistent.interfaces import IPersistentDataManager	1✔
62	from zope.interface import implementer	1✔
63
64	@implementer(IPersistentDataManager)	1✔
65	class _Jar:	1✔
66	def __init__(self):	1✔
67	self._loaded = []	1✔
68	self._registered = []	1✔
69
70	def setstate(self, obj):	1✔
71	self._loaded.append(obj._p_oid)	1✔
72
73	def register(self, obj):	1✔
74	self._registered.append(obj._p_oid)	1✔
75
76	jar = _Jar()	1✔
77	jar._cache = self._makeCache(jar)	1✔
78	return jar	1✔
79
80	def _makeOneWithJar(self, dirty=False, **kw):	1✔
81	# Borrowed from persistent.tests.test_pyPersistence.
82	OID = _makeOctets('\x01' * 8)	1✔
83	inst = self._makeOne(**kw)	1✔
84	jar = self._makeJar()	1✔
85	jar._cache.new_ghost(OID, inst) # assigns _p_jar, _p_oid	1✔
86	return inst, jar, OID	1✔
87
88	def test_changed_original_is_not_us(self):	1✔
89	registry, jar, OID = self._makeOneWithJar()	1✔
90	self.assertEqual(registry._generation, 1)	1✔
91	registry.changed(object())	1✔
92	# 'originally_changed' is not us, but we are still dirty because
93	# '_generation' gets bumped.
94	self.assertEqual(registry._p_changed, True)	1✔
95	# base class gets called
96	self.assertEqual(registry._generation, 2)	1✔
97
98	def test_changed_original_is_us(self):	1✔
99	registry, jar, OID = self._makeOneWithJar()	1✔
100	self.assertEqual(registry._generation, 1)	1✔
101	registry.changed(registry)	1✔
102	# 'originally_changed' is not us, so not dirty
103	self.assertEqual(registry._p_changed, True)	1✔
104	# base class gets called
105	self.assertEqual(registry._generation, 2)	1✔
106
107	def test___getstate___simple(self):	1✔
108	from zope.component import globalSiteManager	1✔
109	bases = (globalSiteManager.adapters, globalSiteManager.utilities)	1✔
110	registry, jar, OID = self._makeOneWithJar(bases=bases)	1✔
111	state = registry.__getstate__()	1✔
112	self.assertEqual(state.pop('__bases__'), bases)	1✔
113	self.assertEqual(state.pop('_generation'), 1)	1✔
114	self.assertEqual(state.pop('_provided'), {})	1✔
115	self.assertEqual(state.pop('_adapters'), [])	1✔
116	self.assertEqual(state.pop('_subscribers'), [])	1✔
117	self.assertNotIn('ro', state)	1✔
118	self.assertEqual(state, {})	1✔
119
120	def test___getstate___skips_delegated_names(self):	1✔
121	registry, jar, OID = self._makeOneWithJar()	1✔
122	registry.names = lambda *args: ['a', 'b', 'c']	1!
123	self.assertFalse('names' in registry.__getstate__())	1✔
124
125	def test___setstate___rebuilds__v_lookup(self):	1✔
126	registry, jar, OID = self._makeOneWithJar()	1✔
127	state = registry.__getstate__()	1✔
128	self.assertTrue('_v_lookup' in registry.__dict__)	1✔
129	registry._p_changed = None # clears volatile '_v_lookup'	1✔
130	self.assertFalse('_v_lookup' in registry.__dict__)	1✔
131	registry.__setstate__(state)	1✔
132	self.assertTrue('_v_lookup' in registry.__dict__)	1✔
133
134	def test___setstate___rebuilds__ro(self):	1✔
135	from zope.component import globalSiteManager	1✔
136	bases = (globalSiteManager.adapters, globalSiteManager.utilities)	1✔
137	registry, jar, OID = self._makeOneWithJar(bases=bases)	1✔
138	state = registry.__getstate__()	1✔
139	registry.__setstate__(state)	1✔
140	self.assertEqual(registry.__bases__, bases)	1✔
141	self.assertEqual(registry.ro, [registry] + list(bases))	1✔
142
143	def test__addValueToLeaf_existing_is_tuple_converts(self):	1✔
144	from persistent.list import PersistentList	1✔
145	registry = self._makeOne()	1✔
146	# It converts when the tuple is not empty...
147	result = registry._addValueToLeaf(('a',), 'b')	1✔
148	self.assertIsInstance(result, PersistentList)	1✔
149	self.assertEqual(result, ['a', 'b'])	1✔
150	# ...and when it is empty...
151	result = registry._addValueToLeaf((), 'b')	1✔
152	self.assertIsInstance(result, PersistentList)	1✔
153	self.assertEqual(result, ['b'])	1✔
154	# ...and in fact when it is even missing
155	result = registry._addValueToLeaf(None, 'b')	1✔
156	self.assertIsInstance(result, PersistentList)	1✔
157	self.assertEqual(result, ['b'])	1✔
158
159	def test__removeValueFromLeaf_existing_is_tuple_converts(self):	1✔
160	from persistent.list import PersistentList	1✔
161	registry = self._makeOne()	1✔
162	# It converts when the item is found...
163	result = registry._removeValueFromLeaf(('a', 'b'), 'b')	1✔
164	self.assertIsInstance(result, PersistentList)	1✔
165	self.assertEqual(result, ['a'])	1✔
166	# ...and when it is not found
167	result = registry._removeValueFromLeaf(('a',), 'b')	1✔
168	self.assertIsInstance(result, PersistentList)	1✔
169	self.assertEqual(result, ['a'])	1✔
170
171	def test__addValueFromLeaf_preserves_identity(self):	1✔
172	registry = self._makeOne()	1✔
173	first = registry._addValueToLeaf(None, 'a')	1✔
174	second = registry._addValueToLeaf(first, 'b')	1✔
175	self.assertIs(first, second)	1✔
176	self.assertEqual(second, ['a', 'b'])	1✔
177
178	def test__removeValueFromLeaf_preserves_identity(self):	1✔
179	registry = self._makeOne()	1✔
180	first = registry._addValueToLeaf(None, 'a')	1✔
181	second = registry._addValueToLeaf(first, 'b')	1✔
182	third = registry._addValueToLeaf(second, 'c')	1✔
183	fourth = registry._removeValueFromLeaf(third, 'c')	1✔
184	self.assertIs(first, second)	1✔
185	self.assertIs(third, fourth)	1✔
186	self.assertIs(first, fourth)	1✔
187	self.assertEqual(fourth, ['a', 'b'])	1✔
188
189
190	@skipIfNoPersistent	1✔
191	class PersistentComponentsTests(unittest.TestCase):	1✔
192
193	def _getTargetClass(self):	1✔
194	from zope.component.persistentregistry import PersistentComponents	1✔
195	return PersistentComponents	1✔
196
197	def _makeOne(self, args, *kw):	1✔
198	return self._getTargetClass()(args, *kw)	1✔
199
200	def test_ctor_initializes_registries_and_registrations(self):	1✔
201	from persistent.list import PersistentList	1✔
202	from persistent.mapping import PersistentMapping	1✔
203
204	from zope.component.persistentregistry import PersistentAdapterRegistry	1✔
205	registry = self._makeOne()	1✔
206	self.assertTrue(isinstance(registry.adapters,	1✔
207	PersistentAdapterRegistry))
208	self.assertTrue(isinstance(registry.utilities,	1✔
209	PersistentAdapterRegistry))
210	self.assertTrue(isinstance(registry._adapter_registrations,	1✔
211	PersistentMapping))
212	self.assertTrue(isinstance(registry._utility_registrations,	1✔
213	PersistentMapping))
214	self.assertTrue(isinstance(registry._subscription_registrations,	1✔
215	PersistentList))
216	self.assertTrue(isinstance(registry._handler_registrations,	1✔
217	PersistentList))
218
219
220	def _makeOctets(s):	1✔
221	return bytes(s) if bytes is str else bytes(s, 'ascii')	1✔
222
223
224	@skipIfNoPersistent	1✔
225	class PersistentAdapterRegistryCustomTypesTest(	1✔
226	CustomTypesBaseAdapterRegistryTests):
227
228	def _getMappingType(self):	1✔
229	from persistent.mapping import PersistentMapping	1✔
230	return PersistentMapping	1✔
231
232	def _getProvidedType(self):	1✔
233	return self._getMappingType()	1✔
234
235	def _getMutableListType(self):	1✔
236	from persistent.list import PersistentList	1✔
237	return PersistentList	1✔
238
239	def _getLeafSequenceType(self):	1✔
240	return self._getMutableListType()	1✔
241
242	def _getBaseAdapterRegistry(self):	1✔
243	from zope.component.persistentregistry import PersistentAdapterRegistry	1✔
244	return PersistentAdapterRegistry	1✔

zopefoundation / zope.component / 4696882551

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous