9511385053

Committed 14 Jun 2024 05:58AM UTC coverage: 90.57% (+0.4%) from 90.185%

Build # 9511385053

Build Type

Pull #119

github

Committed by

icemac

Commit Message

Drop support for Python 3.7.

Pull Request Pull Request #119: - Add support for Python 3.12. - Drop support for Python 3.7.

Run Details

1735 of 2189 branches covered (79.26%)

Branch coverage included in aggregate %.

20 of 24 new or added lines in 8 files covered. (83.33%)

1 existing line in 1 file now uncovered.

9588 of 10313 relevant lines covered (92.97%)

0.93 hits per line

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

89.51

/src/Products/PluggableAuthService/plugins/tests/test_DomainAuthHelper.py

##############################################################################
#
# Copyright (c) 2006 Zope Foundation and Contributors
#
# 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

from ...tests.conformance import IAuthenticationPlugin_conformance
from ...tests.conformance import IExtractionPlugin_conformance
from ...tests.conformance import IRolesPlugin_conformance


try:
    from IPy import IP
except ModuleNotFoundError:
    IP = None


class FauxRequest:

    def __init__(self, **kw):
        self._data = dict(kw)

    def get(self, key, default=None):
        return self._data.get(key, default)


class FauxRequestWithClientAddr(FauxRequest):

    def getClientAddr(self):
        return self._data.get('CLIENT_ADDR')


class DomainAuthHelperTests(unittest.TestCase, IExtractionPlugin_conformance,
                            IAuthenticationPlugin_conformance,
                            IRolesPlugin_conformance):

    def _getTargetClass(self):

        from ...plugins.DomainAuthHelper import DomainAuthHelper

        return DomainAuthHelper

    def _makeOne(self, id='test', *args, **kw):

        return self._getTargetClass()(id=id, *args, **kw)

    def test_extractCredentials_no_creds(self):

        helper = self._makeOne()
        request = FauxRequest()

        self.assertEqual(helper.extractCredentials(request), {})

    def test_extractCredentials_with_getClientAddr(self):

        helper = self._makeOne()
        request = FauxRequestWithClientAddr(REMOTE_HOST='foo',
                                            CLIENT_ADDR='bar')

        self.assertEqual(helper.extractCredentials(request), {
            'remote_host': 'foo',
            'remote_address': 'bar'
        })

    def test_extractCredentials_no_getClientAddr_with_REMOTE_ADDR(self):

        helper = self._makeOne()
        request = FauxRequest(REMOTE_HOST='foo', REMOTE_ADDR='bam')

        self.assertEqual(helper.extractCredentials(request), {
            'remote_host': 'foo',
            'remote_address': 'bam'
        })

    def test_extractCredentials_with_getClientAddr_no_REMOTE_HSOT(self):

        helper = self._makeOne()
        request = FauxRequestWithClientAddr(CLIENT_ADDR='bar')

        self.assertEqual(helper.extractCredentials(request), {
            'remote_host': '',
            'remote_address': 'bar'
        })

    def test_extractCredentials_with_REMOTE_ADDR_no_REMOTE_HOST(self):

        helper = self._makeOne()
        request = FauxRequest(REMOTE_ADDR='bam')

        self.assertEqual(helper.extractCredentials(request), {
            'remote_host': '',
            'remote_address': 'bam'
        })

    def test_extractCredentials_no_getClientAddr_no_REMOTE_ADDR(self):

        helper = self._makeOne()
        request = FauxRequest(REMOTE_HOST='foo')

        self.assertEqual(helper.extractCredentials(request), {
            'remote_host': 'foo',
            'remote_address': ''
        })

    def test_authenticateCredentials_empty_mapping_empty_creds(self):
        creds = {}
        helper = self._makeOne()
        self.assertEqual(helper.authenticateCredentials(creds), (None, None))

    def test_authenticateCredentials_empty_mapping_nonesuch_remote_host(self):
        creds = {'remote_host': 'foo'}
        helper = self._makeOne()
        self.assertEqual(helper.authenticateCredentials(creds), (None, None))

    def test_authenticateCredentials_empty_mapping_nonesuch_remote_addr(self):
        creds = {'remote_address': 'bam'}
        helper = self._makeOne()
        self.assertEqual(helper.authenticateCredentials(creds), (None, None))

    def test_authenticateCredentials_w_mapping_known_remote_host(self):
        creds = {'login': 'qux', 'remote_host': 'bam'}
        helper = self._makeOne()
        helper.manage_addMapping(match_type='equals', match_string='bam')

        self.assertEqual(helper.authenticateCredentials(creds), ('qux', 'qux'))

    def test_authenticateCredentials_w_mapping_known_remote_addr(self):
        creds = {'login': 'qux', 'remote_address': 'baz'}
        helper = self._makeOne()
        helper.manage_addMapping(match_type='endswith',
                                 match_string='z',
                                 username='foo')

        self.assertEqual(helper.authenticateCredentials(creds), ('qux', 'qux'))

    def test_authenticateCredentials_w_mapping_no_login_known_remote_hst(self):
        creds = {'remote_host': 'baz'}
        helper = self._makeOne()
        helper.manage_addMapping(match_type='equals',
                                 match_string='baz',
                                 username='foo')

        self.assertEqual(helper.authenticateCredentials(creds), ('foo', 'foo'))

    # ???  add tests for getRolesForPrincipal, etc.


class EqualsFilterTests(unittest.TestCase):

    def _getTargetClass(self):
        from ...plugins.DomainAuthHelper import EqualsFilter
        return EqualsFilter

    def _makeOne(self, matchstring):
        return self._getTargetClass()(matchstring)

    def test_hit(self):
        filter = self._makeOne('hitme')
        self.assertTrue(filter('hitme'))

    def test_miss(self):
        filter = self._makeOne('hitme')
        self.assertFalse(filter('miss'))


class StartsWithFilterTests(unittest.TestCase):

    def _getTargetClass(self):
        from ...plugins.DomainAuthHelper import StartsWithFilter
        return StartsWithFilter

    def _makeOne(self, matchstring):
        return self._getTargetClass()(matchstring)

    def test_hit_exact(self):
        filter = self._makeOne('hitme')
        self.assertTrue(filter('hitme'))

    def test_hit_prefix(self):
        filter = self._makeOne('hit')
        self.assertTrue(filter('hitme'))

    def test_miss(self):
        filter = self._makeOne('hitme')
        self.assertFalse(filter('miss'))


class EndsWithFilterTests(unittest.TestCase):

    def _getTargetClass(self):
        from ...plugins.DomainAuthHelper import EndsWithFilter
        return EndsWithFilter

    def _makeOne(self, matchstring):
        return self._getTargetClass()(matchstring)

    def test_hit_exact(self):
        filter = self._makeOne('hitme')
        self.assertTrue(filter('hitme'))

    def test_hit_suffix(self):
        filter = self._makeOne('tme')
        self.assertTrue(filter('hitme'))

    def test_miss(self):
        filter = self._makeOne('hitme')
        self.assertFalse(filter('miss'))


class RegexFilterTests(unittest.TestCase):

    def _getTargetClass(self):
        from ...plugins.DomainAuthHelper import RegexFilter
        return RegexFilter

    def _makeOne(self, matchstring):
        return self._getTargetClass()(matchstring)

    def test_hit_exact(self):
        filter = self._makeOne('^hitme$')
        self.assertTrue(filter('hitme'))

    def test_hit_pattern(self):
        filter = self._makeOne('^h.*tme$')
        self.assertTrue(filter('hitme'))

    def test_miss(self):
        filter = self._makeOne('^hitme$')
        self.assertFalse(filter('miss'))


class IPFilterTests(unittest.TestCase):

    def _getTargetClass(self):
        from ...plugins.DomainAuthHelper import IPFilter
        return IPFilter

    def _makeOne(self, matchstring):
        return self._getTargetClass()(matchstring)

    def test_hit_exact(self):
        filter = self._makeOne('192.168.1.24')
        self.assertTrue(filter('192.168.1.24'))

    def test_miss_exact(self):
        filter = self._makeOne('192.168.1.24')
        self.assertFalse(filter('192.168.1.13'))

    def test_hit_prefix(self):
        filter = self._makeOne('192.168.1.0/24')
        self.assertTrue(filter('192.168.1.13'))

    def test_miss_prefix(self):
        filter = self._makeOne('192.168.1.0/24')
        self.assertFalse(filter('192.168.0.13'))

    def test_hit_range(self):
        filter = self._makeOne('192.168.1.0-192.168.1.255')
        self.assertTrue(filter('192.168.1.13'))

    def test_miss_range(self):
        filter = self._makeOne('192.168.1.0-192.168.1.255')
        self.assertFalse(filter('192.168.0.13'))


def test_suite():
    loadTestsFromTestCase = unittest.defaultTestLoader.loadTestsFromTestCase
    tests = (loadTestsFromTestCase(DomainAuthHelperTests),
             loadTestsFromTestCase(EqualsFilterTests),
             loadTestsFromTestCase(StartsWithFilterTests),
             loadTestsFromTestCase(EndsWithFilterTests),
             loadTestsFromTestCase(RegexFilterTests))

    if IP is not None:
        tests += (loadTestsFromTestCase(IPFilterTests), )

    return unittest.TestSuite(tests)

1	##############################################################################
2	#
3	# Copyright (c) 2006 Zope Foundation and Contributors
4	#
5	# This software is subject to the provisions of the Zope Public License,
6	# Version 2.1 (ZPL). A copy of the ZPL should accompany this
7	# 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	import unittest	1✔
15
16	from ...tests.conformance import IAuthenticationPlugin_conformance	1✔
17	from ...tests.conformance import IExtractionPlugin_conformance	1✔
18	from ...tests.conformance import IRolesPlugin_conformance	1✔
19
20
21	try:	1✔
22	from IPy import IP	1✔
23	except ModuleNotFoundError:	1✔
24	IP = None	1✔
25
26
27	class FauxRequest:	1✔
28
29	def __init__(self, **kw):	1✔
30	self._data = dict(kw)	1✔
31
32	def get(self, key, default=None):	1✔
33	return self._data.get(key, default)	1✔
34
35
36	class FauxRequestWithClientAddr(FauxRequest):	1✔
37
38	def getClientAddr(self):	1✔
39	return self._data.get('CLIENT_ADDR')	1✔
40
41
42	class DomainAuthHelperTests(unittest.TestCase, IExtractionPlugin_conformance,	1✔
43	IAuthenticationPlugin_conformance,
44	IRolesPlugin_conformance):
45
46	def _getTargetClass(self):	1✔
47
48	from ...plugins.DomainAuthHelper import DomainAuthHelper	1✔
49
50	return DomainAuthHelper	1✔
51
52	def _makeOne(self, id='test', args, *kw):	1✔
53
54	return self._getTargetClass()(id=id, args, *kw)	1✔
55
56	def test_extractCredentials_no_creds(self):	1✔
57
58	helper = self._makeOne()	1✔
59	request = FauxRequest()	1✔
60
61	self.assertEqual(helper.extractCredentials(request), {})	1✔
62
63	def test_extractCredentials_with_getClientAddr(self):	1✔
64
65	helper = self._makeOne()	1✔
66	request = FauxRequestWithClientAddr(REMOTE_HOST='foo',	1✔
67	CLIENT_ADDR='bar')
68
69	self.assertEqual(helper.extractCredentials(request), {	1✔
70	'remote_host': 'foo',
71	'remote_address': 'bar'
72	})
73
74	def test_extractCredentials_no_getClientAddr_with_REMOTE_ADDR(self):	1✔
75
76	helper = self._makeOne()	1✔
77	request = FauxRequest(REMOTE_HOST='foo', REMOTE_ADDR='bam')	1✔
78
79	self.assertEqual(helper.extractCredentials(request), {	1✔
80	'remote_host': 'foo',
81	'remote_address': 'bam'
82	})
83
84	def test_extractCredentials_with_getClientAddr_no_REMOTE_HSOT(self):	1✔
85
86	helper = self._makeOne()	1✔
87	request = FauxRequestWithClientAddr(CLIENT_ADDR='bar')	1✔
88
89	self.assertEqual(helper.extractCredentials(request), {	1✔
90	'remote_host': '',
91	'remote_address': 'bar'
92	})
93
94	def test_extractCredentials_with_REMOTE_ADDR_no_REMOTE_HOST(self):	1✔
95
96	helper = self._makeOne()	1✔
97	request = FauxRequest(REMOTE_ADDR='bam')	1✔
98
99	self.assertEqual(helper.extractCredentials(request), {	1✔
100	'remote_host': '',
101	'remote_address': 'bam'
102	})
103
104	def test_extractCredentials_no_getClientAddr_no_REMOTE_ADDR(self):	1✔
105
106	helper = self._makeOne()	1✔
107	request = FauxRequest(REMOTE_HOST='foo')	1✔
108
109	self.assertEqual(helper.extractCredentials(request), {	1✔
110	'remote_host': 'foo',
111	'remote_address': ''
112	})
113
114	def test_authenticateCredentials_empty_mapping_empty_creds(self):	1✔
115	creds = {}	1✔
116	helper = self._makeOne()	1✔
117	self.assertEqual(helper.authenticateCredentials(creds), (None, None))	1✔
118
119	def test_authenticateCredentials_empty_mapping_nonesuch_remote_host(self):	1✔
120	creds = {'remote_host': 'foo'}	1✔
121	helper = self._makeOne()	1✔
122	self.assertEqual(helper.authenticateCredentials(creds), (None, None))	1✔
123
124	def test_authenticateCredentials_empty_mapping_nonesuch_remote_addr(self):	1✔
125	creds = {'remote_address': 'bam'}	1✔
126	helper = self._makeOne()	1✔
127	self.assertEqual(helper.authenticateCredentials(creds), (None, None))	1✔
128
129	def test_authenticateCredentials_w_mapping_known_remote_host(self):	1✔
130	creds = {'login': 'qux', 'remote_host': 'bam'}	1✔
131	helper = self._makeOne()	1✔
132	helper.manage_addMapping(match_type='equals', match_string='bam')	1✔
133
134	self.assertEqual(helper.authenticateCredentials(creds), ('qux', 'qux'))	1✔
135
136	def test_authenticateCredentials_w_mapping_known_remote_addr(self):	1✔
137	creds = {'login': 'qux', 'remote_address': 'baz'}	1✔
138	helper = self._makeOne()	1✔
139	helper.manage_addMapping(match_type='endswith',	1✔
140	match_string='z',
141	username='foo')
142
143	self.assertEqual(helper.authenticateCredentials(creds), ('qux', 'qux'))	1✔
144
145	def test_authenticateCredentials_w_mapping_no_login_known_remote_hst(self):	1✔
146	creds = {'remote_host': 'baz'}	1✔
147	helper = self._makeOne()	1✔
148	helper.manage_addMapping(match_type='equals',	1✔
149	match_string='baz',
150	username='foo')
151
152	self.assertEqual(helper.authenticateCredentials(creds), ('foo', 'foo'))	1✔
153
154	# ??? add tests for getRolesForPrincipal, etc.
155
156
157	class EqualsFilterTests(unittest.TestCase):	1✔
158
159	def _getTargetClass(self):	1✔
160	from ...plugins.DomainAuthHelper import EqualsFilter	1✔
161	return EqualsFilter	1✔
162
163	def _makeOne(self, matchstring):	1✔
164	return self._getTargetClass()(matchstring)	1✔
165
166	def test_hit(self):	1✔
167	filter = self._makeOne('hitme')	1✔
168	self.assertTrue(filter('hitme'))	1✔
169
170	def test_miss(self):	1✔
171	filter = self._makeOne('hitme')	1✔
172	self.assertFalse(filter('miss'))	1✔
173
174
175	class StartsWithFilterTests(unittest.TestCase):	1✔
176
177	def _getTargetClass(self):	1✔
178	from ...plugins.DomainAuthHelper import StartsWithFilter	1✔
179	return StartsWithFilter	1✔
180
181	def _makeOne(self, matchstring):	1✔
182	return self._getTargetClass()(matchstring)	1✔
183
184	def test_hit_exact(self):	1✔
185	filter = self._makeOne('hitme')	1✔
186	self.assertTrue(filter('hitme'))	1✔
187
188	def test_hit_prefix(self):	1✔
189	filter = self._makeOne('hit')	1✔
190	self.assertTrue(filter('hitme'))	1✔
191
192	def test_miss(self):	1✔
193	filter = self._makeOne('hitme')	1✔
194	self.assertFalse(filter('miss'))	1✔
195
196
197	class EndsWithFilterTests(unittest.TestCase):	1✔
198
199	def _getTargetClass(self):	1✔
200	from ...plugins.DomainAuthHelper import EndsWithFilter	1✔
201	return EndsWithFilter	1✔
202
203	def _makeOne(self, matchstring):	1✔
204	return self._getTargetClass()(matchstring)	1✔
205
206	def test_hit_exact(self):	1✔
207	filter = self._makeOne('hitme')	1✔
208	self.assertTrue(filter('hitme'))	1✔
209
210	def test_hit_suffix(self):	1✔
211	filter = self._makeOne('tme')	1✔
212	self.assertTrue(filter('hitme'))	1✔
213
214	def test_miss(self):	1✔
215	filter = self._makeOne('hitme')	1✔
216	self.assertFalse(filter('miss'))	1✔
217
218
219	class RegexFilterTests(unittest.TestCase):	1✔
220
221	def _getTargetClass(self):	1✔
222	from ...plugins.DomainAuthHelper import RegexFilter	1✔
223	return RegexFilter	1✔
224
225	def _makeOne(self, matchstring):	1✔
226	return self._getTargetClass()(matchstring)	1✔
227
228	def test_hit_exact(self):	1✔
229	filter = self._makeOne('^hitme$')	1✔
230	self.assertTrue(filter('hitme'))	1✔
231
232	def test_hit_pattern(self):	1✔
233	filter = self._makeOne('^h.*tme$')	1✔
234	self.assertTrue(filter('hitme'))	1✔
235
236	def test_miss(self):	1✔
237	filter = self._makeOne('^hitme$')	1✔
238	self.assertFalse(filter('miss'))	1✔
239
240
241	class IPFilterTests(unittest.TestCase):	1✔
242
243	def _getTargetClass(self):	1✔
244	from ...plugins.DomainAuthHelper import IPFilter	×
245	return IPFilter	×
246
247	def _makeOne(self, matchstring):	1✔
248	return self._getTargetClass()(matchstring)	×
249
250	def test_hit_exact(self):	1✔
251	filter = self._makeOne('192.168.1.24')	×
252	self.assertTrue(filter('192.168.1.24'))	×
253
254	def test_miss_exact(self):	1✔
255	filter = self._makeOne('192.168.1.24')	×
256	self.assertFalse(filter('192.168.1.13'))	×
257
258	def test_hit_prefix(self):	1✔
259	filter = self._makeOne('192.168.1.0/24')	×
260	self.assertTrue(filter('192.168.1.13'))	×
261
262	def test_miss_prefix(self):	1✔
263	filter = self._makeOne('192.168.1.0/24')	×
264	self.assertFalse(filter('192.168.0.13'))	×
265
266	def test_hit_range(self):	1✔
267	filter = self._makeOne('192.168.1.0-192.168.1.255')	×
268	self.assertTrue(filter('192.168.1.13'))	×
269
270	def test_miss_range(self):	1✔
271	filter = self._makeOne('192.168.1.0-192.168.1.255')	×
272	self.assertFalse(filter('192.168.0.13'))	×
273
274
275	def test_suite():	1✔
276	loadTestsFromTestCase = unittest.defaultTestLoader.loadTestsFromTestCase	1✔
277	tests = (loadTestsFromTestCase(DomainAuthHelperTests),	1✔
278	loadTestsFromTestCase(EqualsFilterTests),
279	loadTestsFromTestCase(StartsWithFilterTests),
280	loadTestsFromTestCase(EndsWithFilterTests),
281	loadTestsFromTestCase(RegexFilterTests))
282
283	if IP is not None:	1!
NEW 284	tests += (loadTestsFromTestCase(IPFilterTests), )	×
285
286	return unittest.TestSuite(tests)	1✔

zopefoundation / Products.PluggableAuthService / 9511385053

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