3956162881

Build Type

push

github

Committed by Michael Howitz

Commit Message

Update to deprecation warning free releases.

Run Details

4401 of 7036 branches covered (62.55%)

Branch coverage included in aggregate %.

27161 of 31488 relevant lines covered (86.26%)

0.86 hits per line

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

97.78

/src/ZPublisher/tests/test_mapply.py

##############################################################################
#
# Copyright (c) 2007 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.
#
##############################################################################

import unittest

import Acquisition
import ExtensionClass
from ZPublisher.mapply import mapply


class MapplyTests(unittest.TestCase):

    def testMethod(self):

        def compute(a, b, c=4):
            return '%d%d%d' % (a, b, c)

        values = {'a': 2, 'b': 3, 'c': 5}
        v = mapply(compute, (), values)
        self.assertEqual(v, '235')

        v = mapply(compute, (7,), values)
        self.assertEqual(v, '735')

    def testClass(self):
        values = {'a': 2, 'b': 3, 'c': 5}

        class c:
            a = 3

            def __call__(self, b, c=4):
                return '%d%d%d' % (self.a, b, c)

            compute = __call__

        cc = c()
        v = mapply(cc, (), values)
        self.assertEqual(v, '335')

        del values['c']
        v = mapply(cc.compute, (), values)
        self.assertEqual(v, '334')

    def testObjectWithCall(self):
        # Make sure that the __call__ of an object can also be another
        # callable object.  mapply will do the right thing and
        # recursive look for __call__ attributes until it finds an
        # actual method:

        class CallableObject:
            def __call__(self, a, b):
                return f'{a}{b}'

        class Container:
            __call__ = CallableObject()

        v = mapply(Container(), (8, 3), {})
        self.assertEqual(v, '83')

    def testUncallableObject(self):
        # Normally, mapply will raise a TypeError if it encounters an
        # uncallable object (e.g. an interger ;))
        self.assertRaises(TypeError, mapply, 2, (), {})

        # Unless you enable the 'maybe' flag, in which case it will
        # only maybe call the object
        self.assertEqual(mapply(2, (), {}, maybe=True), 2)

    def testNoCallButAcquisition(self):
        # Make sure that mapply won't erroneously walk up the
        # Acquisition chain when looking for __call__ attributes:

        class Root(ExtensionClass.Base):
            def __call__(self):
                return 'The root __call__'

        class NoCallButAcquisition(Acquisition.Implicit):
            pass

        ob = NoCallButAcquisition().__of__(Root())
        self.assertRaises(TypeError, mapply, ob, (), {})

1	##############################################################################
2	#
3	# Copyright (c) 2007 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
15	import unittest	1✔
16
17	import Acquisition	1✔
18	import ExtensionClass	1✔
19	from ZPublisher.mapply import mapply	1✔
20
21
22	class MapplyTests(unittest.TestCase):	1✔
23
24	def testMethod(self):	1✔
25
26	def compute(a, b, c=4):	1✔
27	return '%d%d%d' % (a, b, c)	1✔
28
29	values = {'a': 2, 'b': 3, 'c': 5}	1✔
30	v = mapply(compute, (), values)	1✔
31	self.assertEqual(v, '235')	1✔
32
33	v = mapply(compute, (7,), values)	1✔
34	self.assertEqual(v, '735')	1✔
35
36	def testClass(self):	1✔
37	values = {'a': 2, 'b': 3, 'c': 5}	1✔
38
39	class c:	1✔
40	a = 3	1✔
41
42	def __call__(self, b, c=4):	1✔
43	return '%d%d%d' % (self.a, b, c)	1✔
44
45	compute = __call__	1✔
46
47	cc = c()	1✔
48	v = mapply(cc, (), values)	1✔
49	self.assertEqual(v, '335')	1✔
50
51	del values['c']	1✔
52	v = mapply(cc.compute, (), values)	1✔
53	self.assertEqual(v, '334')	1✔
54
55	def testObjectWithCall(self):	1✔
56	# Make sure that the __call__ of an object can also be another
57	# callable object. mapply will do the right thing and
58	# recursive look for __call__ attributes until it finds an
59	# actual method:
60
61	class CallableObject:	1✔
62	def __call__(self, a, b):	1✔
63	return f'{a}{b}'	1✔
64
65	class Container:	1✔
66	__call__ = CallableObject()	1✔
67
68	v = mapply(Container(), (8, 3), {})	1✔
69	self.assertEqual(v, '83')	1✔
70
71	def testUncallableObject(self):	1✔
72	# Normally, mapply will raise a TypeError if it encounters an
73	# uncallable object (e.g. an interger ;))
74	self.assertRaises(TypeError, mapply, 2, (), {})	1✔
75
76	# Unless you enable the 'maybe' flag, in which case it will
77	# only maybe call the object
78	self.assertEqual(mapply(2, (), {}, maybe=True), 2)	1✔
79
80	def testNoCallButAcquisition(self):	1✔
81	# Make sure that mapply won't erroneously walk up the
82	# Acquisition chain when looking for __call__ attributes:
83
84	class Root(ExtensionClass.Base):	1✔
85	def __call__(self):	1✔
86	return 'The root __call__'	×
87
88	class NoCallButAcquisition(Acquisition.Implicit):	1✔
89	pass	1✔
90
91	ob = NoCallButAcquisition().__of__(Root())	1✔
92	self.assertRaises(TypeError, mapply, ob, (), {})	1✔

zopefoundation / Zope / 3956162881

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