6447468609

Committed 05 Oct 2023 12:04PM UTC coverage: 100.0%. Remained the same

Build # 6447468609

Build Type

push

github

Committed by

dataflake

Commit Message

- vb [ci skip]

Run Details

60 of 60 branches covered (100.0%)

Branch coverage included in aggregate %.

245 of 245 relevant lines covered (100.0%)

6.99 hits per line

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

100.0

/src/zope/i18nmessageid/tests.py

##############################################################################
#
# Copyright (c) 2003 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.
#
##############################################################################
"""Message ID tests.
"""
import sys
import unittest

from zope.i18nmessageid import message as messageid


class PyMessageTests(unittest.TestCase):

    _TEST_READONLY = True

    def _getTargetClass(self):
        return messageid.pyMessage

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

    def test_defaults(self):
        message = self._makeOne('testing')
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, None)
        self.assertEqual(message.default, None)
        self.assertEqual(message.mapping, None)
        self.assertEqual(message.msgid_plural, None)
        self.assertEqual(message.default_plural, None)
        self.assertEqual(message.number, None)
        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_values(self):
        mapping = {'key': 'value'}
        message = self._makeOne(
            'testing', 'domain', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=2)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'default')
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, 'defaults')
        self.assertEqual(message.number, 2)
        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_values_without_defaults(self):
        mapping = {'key': 'value'}
        message = self._makeOne(
            'testing', 'domain', mapping=mapping,
            msgid_plural='testings', number=2)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, None)
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, None)
        self.assertEqual(message.number, 2)
        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_values_with_float_for_number(self):
        mapping = {'key': 'value'}
        message = self._makeOne(
            'testing', 'domain', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=2.2)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'default')
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, 'defaults')
        self.assertEqual(message.number, 2.2)
        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_values_with_zero(self):
        mapping = {'key': 'value'}
        message = self._makeOne(
            'testing', 'domain', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=0)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'default')
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, 'defaults')
        self.assertEqual(message.number, 0)
        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_copy(self):
        mapping = {'key': 'value'}
        source = self._makeOne(
            'testing', 'domain', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=0)
        message = self._makeOne(source)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'default')
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, 'defaults')
        self.assertEqual(message.number, 0)

        # Besides just being equal, they maintain their identity
        for attr in (
                'domain',
                'default',
                'mapping',
                'msgid_plural',
                'default_plural',
                'number',
        ):
            self.assertIs(getattr(source, attr),
                          getattr(message, attr))

        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_copy_with_overrides(self):
        mapping = {'key': 'value'}
        source = self._makeOne(
            'testing', 'domain', default='other', mapping=mapping,
            msgid_plural='workings', default_plural='others', number=3)
        message = self._makeOne(
            source, mapping=None, msgid_plural='override', number=0)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'other')
        self.assertEqual(message.mapping, None)
        self.assertEqual(message.msgid_plural, 'override')
        self.assertEqual(message.default_plural, 'others')
        self.assertEqual(message.number, 0)
        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_copy_no_default(self):
        # https://github.com/zopefoundation/zope.i18nmessageid/issues/14
        pref_msg = self._makeOne("${name} Preferences")
        self.assertIsNone(pref_msg.default)
        copy = self._makeOne(pref_msg, mapping={'name': 'name'})
        self.assertIsNone(copy.default)

    def test_copy_no_overrides(self):
        # https://github.com/zopefoundation/zope.i18nmessageid/issues/14
        pref_msg = self._makeOne("${name} Preferences")

        copy = self._makeOne(pref_msg)
        for attr in (
                'domain',
                'default',
                'mapping',
                'msgid_plural',
                'default_plural',
                'number',
        ):
            self.assertIsNone(getattr(pref_msg, attr))
            self.assertIsNone(getattr(copy, attr))

    def test_domain_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.domain = 'domain'

    def test_default_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.default = 'default'

    def test_mapping_immutable(self):
        mapping = {'key': 'value'}
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.mapping = mapping

    def test_msgid_plural_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.msgid_plural = 'bar'

    def test_default_plural_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.default_plural = 'bar'

    def test_number_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.number = 23

    def test_unknown_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.unknown = 'unknown'

    def test___reduce__(self):
        mapping = {'key': 'value'}
        source = self._makeOne('testing')
        message = self._makeOne(
            source, 'domain', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=2)
        klass, state = message.__reduce__()
        self.assertTrue(klass is self._getTargetClass())
        self.assertEqual(
            state,
            ('testing', 'domain', 'default', {'key': 'value'},
             'testings', 'defaults', 2))

    def test_non_unicode_default(self):
        message = self._makeOne('str', default=123)
        self.assertEqual(message.default, 123)

    def test_non_numeric_number(self):
        with self.assertRaises((TypeError, AttributeError)):
            self._makeOne('str', default=123, number="one")


@unittest.skipIf(messageid.Message is messageid.pyMessage, "Duplicate tests")
class MessageTests(PyMessageTests):

    _TEST_READONLY = False

    def _getTargetClass(self):
        return messageid.Message


@unittest.skipIf('java' in sys.platform or hasattr(sys, 'pypy_version_info'),
                 "We don't expect the C implementation here")
class OptimizationTests(unittest.TestCase):

    def test_optimizations_available(self):
        self.assertIsNot(messageid.Message, messageid.pyMessage)


class MessageFactoryTests(unittest.TestCase):

    def _getTargetClass(self):
        return messageid.MessageFactory

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

    def test___call___defaults(self):
        factory = self._makeOne('domain')
        message = factory('testing')
        self.assertTrue(isinstance(message, messageid.Message))
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, None)
        self.assertEqual(message.mapping, None)
        self.assertEqual(message.msgid_plural, None)
        self.assertEqual(message.default_plural, None)
        self.assertEqual(message.number, None)

    def test___call___explicit(self):
        mapping = {'key': 'value'}
        factory = self._makeOne('domain')
        message = factory(
            'testing', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=2)
        self.assertTrue(isinstance(message, messageid.Message))
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'default')
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, 'defaults')
        self.assertEqual(message.number, 2)


def test_suite():
    return unittest.TestSuite((
        unittest.defaultTestLoader.loadTestsFromName(__name__),
    ))

1	##############################################################################
2	#
3	# Copyright (c) 2003 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	"""Message ID tests.	7✔
15	"""
16	import sys	7✔
17	import unittest	7✔
18
19	from zope.i18nmessageid import message as messageid	7✔
20
21
22	class PyMessageTests(unittest.TestCase):	7✔
23
24	_TEST_READONLY = True	7✔
25
26	def _getTargetClass(self):	7✔
27	return messageid.pyMessage	7✔
28
29	def _makeOne(self, args, *kw):	7✔
30	return self._getTargetClass()(args, *kw)	7✔
31
32	def test_defaults(self):	7✔
33	message = self._makeOne('testing')	7✔
34	self.assertEqual(message, 'testing')	7✔
35	self.assertEqual(message.domain, None)	7✔
36	self.assertEqual(message.default, None)	7✔
37	self.assertEqual(message.mapping, None)	7✔
38	self.assertEqual(message.msgid_plural, None)	7✔
39	self.assertEqual(message.default_plural, None)	7✔
40	self.assertEqual(message.number, None)	7✔
41	if self._TEST_READONLY:	7✔
42	self.assertTrue(message._readonly)	7✔
43
44	def test_values(self):	7✔
45	mapping = {'key': 'value'}	7✔
46	message = self._makeOne(	7✔
47	'testing', 'domain', 'default', mapping,
48	msgid_plural='testings', default_plural="defaults", number=2)
49	self.assertEqual(message, 'testing')	7✔
50	self.assertEqual(message.domain, 'domain')	7✔
51	self.assertEqual(message.default, 'default')	7✔
52	self.assertEqual(message.mapping, mapping)	7✔
53	self.assertEqual(message.msgid_plural, 'testings')	7✔
54	self.assertEqual(message.default_plural, 'defaults')	7✔
55	self.assertEqual(message.number, 2)	7✔
56	if self._TEST_READONLY:	7✔
57	self.assertTrue(message._readonly)	7✔
58
59	def test_values_without_defaults(self):	7✔
60	mapping = {'key': 'value'}	7✔
61	message = self._makeOne(	7✔
62	'testing', 'domain', mapping=mapping,
63	msgid_plural='testings', number=2)
64	self.assertEqual(message, 'testing')	7✔
65	self.assertEqual(message.domain, 'domain')	7✔
66	self.assertEqual(message.default, None)	7✔
67	self.assertEqual(message.mapping, mapping)	7✔
68	self.assertEqual(message.msgid_plural, 'testings')	7✔
69	self.assertEqual(message.default_plural, None)	7✔
70	self.assertEqual(message.number, 2)	7✔
71	if self._TEST_READONLY:	7✔
72	self.assertTrue(message._readonly)	7✔
73
74	def test_values_with_float_for_number(self):	7✔
75	mapping = {'key': 'value'}	7✔
76	message = self._makeOne(	7✔
77	'testing', 'domain', 'default', mapping,
78	msgid_plural='testings', default_plural="defaults", number=2.2)
79	self.assertEqual(message, 'testing')	7✔
80	self.assertEqual(message.domain, 'domain')	7✔
81	self.assertEqual(message.default, 'default')	7✔
82	self.assertEqual(message.mapping, mapping)	7✔
83	self.assertEqual(message.msgid_plural, 'testings')	7✔
84	self.assertEqual(message.default_plural, 'defaults')	7✔
85	self.assertEqual(message.number, 2.2)	7✔
86	if self._TEST_READONLY:	7✔
87	self.assertTrue(message._readonly)	7✔
88
89	def test_values_with_zero(self):	7✔
90	mapping = {'key': 'value'}	7✔
91	message = self._makeOne(	7✔
92	'testing', 'domain', 'default', mapping,
93	msgid_plural='testings', default_plural="defaults", number=0)
94	self.assertEqual(message, 'testing')	7✔
95	self.assertEqual(message.domain, 'domain')	7✔
96	self.assertEqual(message.default, 'default')	7✔
97	self.assertEqual(message.mapping, mapping)	7✔
98	self.assertEqual(message.msgid_plural, 'testings')	7✔
99	self.assertEqual(message.default_plural, 'defaults')	7✔
100	self.assertEqual(message.number, 0)	7✔
101	if self._TEST_READONLY:	7✔
102	self.assertTrue(message._readonly)	7✔
103
104	def test_copy(self):	7✔
105	mapping = {'key': 'value'}	7✔
106	source = self._makeOne(	7✔
107	'testing', 'domain', 'default', mapping,
108	msgid_plural='testings', default_plural="defaults", number=0)
109	message = self._makeOne(source)	7✔
110	self.assertEqual(message, 'testing')	7✔
111	self.assertEqual(message.domain, 'domain')	7✔
112	self.assertEqual(message.default, 'default')	7✔
113	self.assertEqual(message.mapping, mapping)	7✔
114	self.assertEqual(message.msgid_plural, 'testings')	7✔
115	self.assertEqual(message.default_plural, 'defaults')	7✔
116	self.assertEqual(message.number, 0)	7✔
117
118	# Besides just being equal, they maintain their identity
119	for attr in (	7✔
120	'domain',
121	'default',
122	'mapping',
123	'msgid_plural',
124	'default_plural',
125	'number',
126	):
127	self.assertIs(getattr(source, attr),	7✔
128	getattr(message, attr))
129
130	if self._TEST_READONLY:	7✔
131	self.assertTrue(message._readonly)	7✔
132
133	def test_copy_with_overrides(self):	7✔
134	mapping = {'key': 'value'}	7✔
135	source = self._makeOne(	7✔
136	'testing', 'domain', default='other', mapping=mapping,
137	msgid_plural='workings', default_plural='others', number=3)
138	message = self._makeOne(	7✔
139	source, mapping=None, msgid_plural='override', number=0)
140	self.assertEqual(message, 'testing')	7✔
141	self.assertEqual(message.domain, 'domain')	7✔
142	self.assertEqual(message.default, 'other')	7✔
143	self.assertEqual(message.mapping, None)	7✔
144	self.assertEqual(message.msgid_plural, 'override')	7✔
145	self.assertEqual(message.default_plural, 'others')	7✔
146	self.assertEqual(message.number, 0)	7✔
147	if self._TEST_READONLY:	7✔
148	self.assertTrue(message._readonly)	7✔
149
150	def test_copy_no_default(self):	7✔
151	# https://github.com/zopefoundation/zope.i18nmessageid/issues/14
152	pref_msg = self._makeOne("${name} Preferences")	7✔
153	self.assertIsNone(pref_msg.default)	7✔
154	copy = self._makeOne(pref_msg, mapping={'name': 'name'})	7✔
155	self.assertIsNone(copy.default)	7✔
156
157	def test_copy_no_overrides(self):	7✔
158	# https://github.com/zopefoundation/zope.i18nmessageid/issues/14
159	pref_msg = self._makeOne("${name} Preferences")	7✔
160
161	copy = self._makeOne(pref_msg)	7✔
162	for attr in (	7✔
163	'domain',
164	'default',
165	'mapping',
166	'msgid_plural',
167	'default_plural',
168	'number',
169	):
170	self.assertIsNone(getattr(pref_msg, attr))	7✔
171	self.assertIsNone(getattr(copy, attr))	7✔
172
173	def test_domain_immutable(self):	7✔
174	message = self._makeOne('testing')	7✔
175	with self.assertRaises((TypeError, AttributeError)):	7✔
176	message.domain = 'domain'	7✔
177
178	def test_default_immutable(self):	7✔
179	message = self._makeOne('testing')	7✔
180	with self.assertRaises((TypeError, AttributeError)):	7✔
181	message.default = 'default'	7✔
182
183	def test_mapping_immutable(self):	7✔
184	mapping = {'key': 'value'}	7✔
185	message = self._makeOne('testing')	7✔
186	with self.assertRaises((TypeError, AttributeError)):	7✔
187	message.mapping = mapping	7✔
188
189	def test_msgid_plural_immutable(self):	7✔
190	message = self._makeOne('testing')	7✔
191	with self.assertRaises((TypeError, AttributeError)):	7✔
192	message.msgid_plural = 'bar'	7✔
193
194	def test_default_plural_immutable(self):	7✔
195	message = self._makeOne('testing')	7✔
196	with self.assertRaises((TypeError, AttributeError)):	7✔
197	message.default_plural = 'bar'	7✔
198
199	def test_number_immutable(self):	7✔
200	message = self._makeOne('testing')	7✔
201	with self.assertRaises((TypeError, AttributeError)):	7✔
202	message.number = 23	7✔
203
204	def test_unknown_immutable(self):	7✔
205	message = self._makeOne('testing')	7✔
206	with self.assertRaises((TypeError, AttributeError)):	7✔
207	message.unknown = 'unknown'	7✔
208
209	def test___reduce__(self):	7✔
210	mapping = {'key': 'value'}	7✔
211	source = self._makeOne('testing')	7✔
212	message = self._makeOne(	7✔
213	source, 'domain', 'default', mapping,
214	msgid_plural='testings', default_plural="defaults", number=2)
215	klass, state = message.__reduce__()	7✔
216	self.assertTrue(klass is self._getTargetClass())	7✔
217	self.assertEqual(	7✔
218	state,
219	('testing', 'domain', 'default', {'key': 'value'},
220	'testings', 'defaults', 2))
221
222	def test_non_unicode_default(self):	7✔
223	message = self._makeOne('str', default=123)	7✔
224	self.assertEqual(message.default, 123)	7✔
225
226	def test_non_numeric_number(self):	7✔
227	with self.assertRaises((TypeError, AttributeError)):	7✔
228	self._makeOne('str', default=123, number="one")	7✔
229
230
231	@unittest.skipIf(messageid.Message is messageid.pyMessage, "Duplicate tests")	7✔
232	class MessageTests(PyMessageTests):	7✔
233
234	_TEST_READONLY = False	7✔
235
236	def _getTargetClass(self):	7✔
237	return messageid.Message	6✔
238
239
240	@unittest.skipIf('java' in sys.platform or hasattr(sys, 'pypy_version_info'),	7✔
241	"We don't expect the C implementation here")
242	class OptimizationTests(unittest.TestCase):	7✔
243
244	def test_optimizations_available(self):	7✔
245	self.assertIsNot(messageid.Message, messageid.pyMessage)	6✔
246
247
248	class MessageFactoryTests(unittest.TestCase):	7✔
249
250	def _getTargetClass(self):	7✔
251	return messageid.MessageFactory	7✔
252
253	def _makeOne(self, args, *kw):	7✔
254	return self._getTargetClass()(args, *kw)	7✔
255
256	def test___call___defaults(self):	7✔
257	factory = self._makeOne('domain')	7✔
258	message = factory('testing')	7✔
259	self.assertTrue(isinstance(message, messageid.Message))	7✔
260	self.assertEqual(message, 'testing')	7✔
261	self.assertEqual(message.domain, 'domain')	7✔
262	self.assertEqual(message.default, None)	7✔
263	self.assertEqual(message.mapping, None)	7✔
264	self.assertEqual(message.msgid_plural, None)	7✔
265	self.assertEqual(message.default_plural, None)	7✔
266	self.assertEqual(message.number, None)	7✔
267
268	def test___call___explicit(self):	7✔
269	mapping = {'key': 'value'}	7✔
270	factory = self._makeOne('domain')	7✔
271	message = factory(	7✔
272	'testing', 'default', mapping,
273	msgid_plural='testings', default_plural="defaults", number=2)
274	self.assertTrue(isinstance(message, messageid.Message))	7✔
275	self.assertEqual(message, 'testing')	7✔
276	self.assertEqual(message.domain, 'domain')	7✔
277	self.assertEqual(message.default, 'default')	7✔
278	self.assertEqual(message.mapping, mapping)	7✔
279	self.assertEqual(message.msgid_plural, 'testings')	7✔
280	self.assertEqual(message.default_plural, 'defaults')	7✔
281	self.assertEqual(message.number, 2)	7✔
282
283
284	def test_suite():	7✔
285	return unittest.TestSuite((	7✔
286	unittest.defaultTestLoader.loadTestsFromName(__name__),
287	))

zopefoundation / zope.i18nmessageid / 6447468609

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