6263629025

Committed 21 Sep 2023 03:12PM UTC coverage: 82.146% (-0.01%) from 82.159%

Build # 6263629025

Build Type

Pull #1164

github

Committed by

web-flow

Commit Message

[pre-commit.ci lite] apply automatic fixes

Pull Request Pull Request #1164: Move all linters to pre-commit.

Run Details

4353 of 6963 branches covered (0.0%)

Branch coverage included in aggregate %.

487 of 487 new or added lines in 186 files covered. (100.0%)

27394 of 31684 relevant lines covered (86.46%)

0.86 hits per line

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

90.09

/src/OFS/tests/testSimpleItem.py

import unittest


class TestItem(unittest.TestCase):

    def _getTargetClass(self):
        from OFS.SimpleItem import Item
        return Item

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

    def test_conforms_to_IItem(self):
        from OFS.interfaces import IItem
        from zope.interface.verify import verifyClass

        verifyClass(IItem, self._getTargetClass())

    def test_conforms_to_IManageable(self):
        from OFS.interfaces import IManageable
        from zope.interface.verify import verifyClass

        verifyClass(IManageable, self._getTargetClass())

    def test_raise_StandardErrorMessage_str_errorValue(self):
        class REQUEST:
            class RESPONSE:
                handle_errors = True
        item = self._makeOne()

        def _raise_during_standard_error_message(*args, **kw):
            raise ZeroDivisionError('testing')
        item.standard_error_message = _raise_during_standard_error_message
        try:
            item.raise_standardErrorMessage(
                error_type=OverflowError,
                error_value=OverflowError('simple'),
                REQUEST=REQUEST(),
            )
        except Exception:
            import sys
            self.assertEqual(sys.exc_info()[0], OverflowError)
            value = sys.exc_info()[1]
            self.assertTrue(value.message.startswith("'simple'"))
            self.assertIn('full details: testing', value.message)

    def test_raise_StandardErrorMessage_TaintedString_errorValue(self):
        from AccessControl.tainted import TaintedString

        class REQUEST:
            class RESPONSE:
                handle_errors = True
        item = self._makeOne()

        def _raise_during_standard_error_message(*args, **kw):
            raise ZeroDivisionError('testing')
        item.standard_error_message = _raise_during_standard_error_message
        try:
            item.raise_standardErrorMessage(
                error_type=OverflowError,
                error_value=OverflowError(TaintedString('<simple>')),
                REQUEST=REQUEST(),
            )
        except Exception:
            import sys
            self.assertEqual(sys.exc_info()[0], OverflowError)
            value = sys.exc_info()[1]
            self.assertNotIn('<', value.message)


class TestItem_w__name__(unittest.TestCase):

    def test_interfaces(self):
        from OFS.interfaces import IItemWithName
        from OFS.SimpleItem import Item_w__name__
        from zope.interface.verify import verifyClass

        verifyClass(IItemWithName, Item_w__name__)

    def test_id(self):
        from OFS.SimpleItem import Item_w__name__
        itm = Item_w__name__()
        # fall back to inherited `id`
        self.assertEqual(itm.id, "")
        itm.id = "id"
        self.assertEqual(itm.id, "id")
        del itm.id
        itm._setId("name")
        self.assertEqual(itm.id, "name")


class TestSimpleItem(unittest.TestCase):

    def _getTargetClass(self):
        from OFS.SimpleItem import SimpleItem
        return SimpleItem

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

    def test_interfaces(self):
        from OFS.interfaces import ISimpleItem
        from zope.interface.verify import verifyClass

        verifyClass(ISimpleItem, self._getTargetClass())

    def test_title_or_id_nonascii(self):
        unencoded_id = '\xfc\xe4\xee\xe9\xdf_id'
        unencoded_title = '\xfc\xe4\xee\xe9\xdf Title'
        item = self._makeOne()

        item.id = unencoded_id
        self.assertEqual(item.title_or_id(), unencoded_id)

        item.title = unencoded_title
        self.assertEqual(item.title_or_id(), unencoded_title)

    def test_title_and_id_nonascii(self):
        unencoded_id = '\xfc\xe4\xee\xe9\xdf_id'
        encoded_id = unencoded_id.encode('UTF-8')
        unencoded_title = '\xfc\xe4\xee\xe9\xdf Title'
        item = self._makeOne()

        item.id = unencoded_id
        self.assertEqual(item.title_and_id(), unencoded_id)

        item.title = unencoded_title
        self.assertIn(unencoded_id, item.title_and_id())
        self.assertIn(unencoded_title, item.title_and_id())

        # Now mix encoded and unencoded. The combination is a native string:
        item.id = encoded_id
        self.assertIn(unencoded_id, item.title_and_id())
        self.assertIn(unencoded_title, item.title_and_id())

    def test_standard_error_message_is_called(self):
        from zExceptions import BadRequest

        # handle_errors should default to True. It is a flag used for
        # functional doctests. See ZPublisher/Test.py and
        # ZPublisher/Publish.py.
        class REQUEST:
            class RESPONSE:
                handle_errors = True

        class StandardErrorMessage:
            def __init__(self):
                self.kw = {}

            def __call__(self, **kw):
                self.kw.clear()
                self.kw.update(kw)

        item = self._makeOne()
        item.standard_error_message = sem = StandardErrorMessage()

        try:
            raise BadRequest("1")
        except Exception:
            item.raise_standardErrorMessage(client=item,
                                            REQUEST=REQUEST())

        self.assertEqual(sem.kw.get('error_type'), 'BadRequest')

1	import unittest	1✔
2
3
4	class TestItem(unittest.TestCase):	1✔
5
6	def _getTargetClass(self):	1✔
7	from OFS.SimpleItem import Item	1✔
8	return Item	1✔
9
10	def _makeOne(self, args, *kw):	1✔
11	return self._getTargetClass()(args, *kw)	1✔
12
13	def test_conforms_to_IItem(self):	1✔
14	from OFS.interfaces import IItem	1✔
15	from zope.interface.verify import verifyClass	1✔
16
17	verifyClass(IItem, self._getTargetClass())	1✔
18
19	def test_conforms_to_IManageable(self):	1✔
20	from OFS.interfaces import IManageable	1✔
21	from zope.interface.verify import verifyClass	1✔
22
23	verifyClass(IManageable, self._getTargetClass())	1✔
24
25	def test_raise_StandardErrorMessage_str_errorValue(self):	1✔
26	class REQUEST:	1✔
27	class RESPONSE:	1✔
28	handle_errors = True	1✔
29	item = self._makeOne()	1✔
30
31	def _raise_during_standard_error_message(args, *kw):	1✔
32	raise ZeroDivisionError('testing')	1✔
33	item.standard_error_message = _raise_during_standard_error_message	1✔
34	try:	1✔
35	item.raise_standardErrorMessage(	1✔
36	error_type=OverflowError,
37	error_value=OverflowError('simple'),
38	REQUEST=REQUEST(),
39	)
40	except Exception:	×
41	import sys	×
42	self.assertEqual(sys.exc_info()[0], OverflowError)	×
43	value = sys.exc_info()[1]	×
44	self.assertTrue(value.message.startswith("'simple'"))	×
45	self.assertIn('full details: testing', value.message)	×
46
47	def test_raise_StandardErrorMessage_TaintedString_errorValue(self):	1✔
48	from AccessControl.tainted import TaintedString	1✔
49
50	class REQUEST:	1✔
51	class RESPONSE:	1✔
52	handle_errors = True	1✔
53	item = self._makeOne()	1✔
54
55	def _raise_during_standard_error_message(args, *kw):	1✔
56	raise ZeroDivisionError('testing')	1✔
57	item.standard_error_message = _raise_during_standard_error_message	1✔
58	try:	1✔
59	item.raise_standardErrorMessage(	1✔
60	error_type=OverflowError,
61	error_value=OverflowError(TaintedString('<simple>')),
62	REQUEST=REQUEST(),
63	)
64	except Exception:	×
65	import sys	×
66	self.assertEqual(sys.exc_info()[0], OverflowError)	×
67	value = sys.exc_info()[1]	×
68	self.assertNotIn('<', value.message)	×
69
70
71	class TestItem_w__name__(unittest.TestCase):	1✔
72
73	def test_interfaces(self):	1✔
74	from OFS.interfaces import IItemWithName	1✔
75	from OFS.SimpleItem import Item_w__name__	1✔
76	from zope.interface.verify import verifyClass	1✔
77
78	verifyClass(IItemWithName, Item_w__name__)	1✔
79
80	def test_id(self):	1✔
81	from OFS.SimpleItem import Item_w__name__	1✔
82	itm = Item_w__name__()	1✔
83	# fall back to inherited `id`
84	self.assertEqual(itm.id, "")	1✔
85	itm.id = "id"	1✔
86	self.assertEqual(itm.id, "id")	1✔
87	del itm.id	1✔
88	itm._setId("name")	1✔
89	self.assertEqual(itm.id, "name")	1✔
90
91
92	class TestSimpleItem(unittest.TestCase):	1✔
93
94	def _getTargetClass(self):	1✔
95	from OFS.SimpleItem import SimpleItem	1✔
96	return SimpleItem	1✔
97
98	def _makeOne(self, args, *kw):	1✔
99	return self._getTargetClass()(args, *kw)	1✔
100
101	def test_interfaces(self):	1✔
102	from OFS.interfaces import ISimpleItem	1✔
103	from zope.interface.verify import verifyClass	1✔
104
105	verifyClass(ISimpleItem, self._getTargetClass())	1✔
106
107	def test_title_or_id_nonascii(self):	1✔
108	unencoded_id = '\xfc\xe4\xee\xe9\xdf_id'	1✔
109	unencoded_title = '\xfc\xe4\xee\xe9\xdf Title'	1✔
110	item = self._makeOne()	1✔
111
112	item.id = unencoded_id	1✔
113	self.assertEqual(item.title_or_id(), unencoded_id)	1✔
114
115	item.title = unencoded_title	1✔
116	self.assertEqual(item.title_or_id(), unencoded_title)	1✔
117
118	def test_title_and_id_nonascii(self):	1✔
119	unencoded_id = '\xfc\xe4\xee\xe9\xdf_id'	1✔
120	encoded_id = unencoded_id.encode('UTF-8')	1✔
121	unencoded_title = '\xfc\xe4\xee\xe9\xdf Title'	1✔
122	item = self._makeOne()	1✔
123
124	item.id = unencoded_id	1✔
125	self.assertEqual(item.title_and_id(), unencoded_id)	1✔
126
127	item.title = unencoded_title	1✔
128	self.assertIn(unencoded_id, item.title_and_id())	1✔
129	self.assertIn(unencoded_title, item.title_and_id())	1✔
130
131	# Now mix encoded and unencoded. The combination is a native string:
132	item.id = encoded_id	1✔
133	self.assertIn(unencoded_id, item.title_and_id())	1✔
134	self.assertIn(unencoded_title, item.title_and_id())	1✔
135
136	def test_standard_error_message_is_called(self):	1✔
137	from zExceptions import BadRequest	1✔
138
139	# handle_errors should default to True. It is a flag used for
140	# functional doctests. See ZPublisher/Test.py and
141	# ZPublisher/Publish.py.
142	class REQUEST:	1✔
143	class RESPONSE:	1✔
144	handle_errors = True	1✔
145
146	class StandardErrorMessage:	1✔
147	def __init__(self):	1✔
148	self.kw = {}	1✔
149
150	def __call__(self, **kw):	1✔
151	self.kw.clear()	1✔
152	self.kw.update(kw)	1✔
153
154	item = self._makeOne()	1✔
155	item.standard_error_message = sem = StandardErrorMessage()	1✔
156
157	try:	1✔
158	raise BadRequest("1")	1✔
159	except Exception:	1✔
160	item.raise_standardErrorMessage(client=item,	1✔
161	REQUEST=REQUEST())
162
163	self.assertEqual(sem.kw.get('error_type'), 'BadRequest')	1✔

zopefoundation / Zope / 6263629025

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