5303493172

pending completion

Build # 5303493172

Build Type

push

github

Committed by

web-flow

Commit Message

Drop support for Python 2.7, 3.5, 3.6. (#116)

* Drop zserver extra in setup.py. Thus dropping FTP support.
* Drop support for Zope < 5.
Co-authored-by: Jens Vagelpohl <jens@plyp.com>

Run Details

1288 of 1745 branches covered (73.81%)

Branch coverage included in aggregate %.

127 of 127 new or added lines in 30 files covered. (100.0%)

9619 of 10349 relevant lines covered (92.95%)

0.93 hits per line

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

89.38

/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 ImportError:
    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 ImportError:
24	IP = None
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	def test_extractCredentials_no_getClientAddr_with_REMOTE_ADDR(self):	1✔
74
75	helper = self._makeOne()	1✔
76	request = FauxRequest(REMOTE_HOST='foo',	1✔
77	REMOTE_ADDR='bam')
78
79	self.assertEqual(helper.extractCredentials(request),	1✔
80	{'remote_host': 'foo',
81	'remote_address': 'bam'})
82
83	def test_extractCredentials_with_getClientAddr_no_REMOTE_HSOT(self):	1✔
84
85	helper = self._makeOne()	1✔
86	request = FauxRequestWithClientAddr(CLIENT_ADDR='bar')	1✔
87
88	self.assertEqual(helper.extractCredentials(request),	1✔
89	{'remote_host': '',
90	'remote_address': 'bar'})
91
92	def test_extractCredentials_with_REMOTE_ADDR_no_REMOTE_HOST(self):	1✔
93
94	helper = self._makeOne()	1✔
95	request = FauxRequest(REMOTE_ADDR='bam')	1✔
96
97	self.assertEqual(helper.extractCredentials(request),	1✔
98	{'remote_host': '',
99	'remote_address': 'bam'})
100
101	def test_extractCredentials_no_getClientAddr_no_REMOTE_ADDR(self):	1✔
102
103	helper = self._makeOne()	1✔
104	request = FauxRequest(REMOTE_HOST='foo')	1✔
105
106	self.assertEqual(helper.extractCredentials(request),	1✔
107	{'remote_host': 'foo',
108	'remote_address': ''})
109
110	def test_authenticateCredentials_empty_mapping_empty_creds(self):	1✔
111	creds = {}	1✔
112	helper = self._makeOne()	1✔
113	self.assertEqual(helper.authenticateCredentials(creds), (None, None))	1✔
114
115	def test_authenticateCredentials_empty_mapping_nonesuch_remote_host(self):	1✔
116	creds = {'remote_host': 'foo'}	1✔
117	helper = self._makeOne()	1✔
118	self.assertEqual(helper.authenticateCredentials(creds), (None, None))	1✔
119
120	def test_authenticateCredentials_empty_mapping_nonesuch_remote_addr(self):	1✔
121	creds = {'remote_address': 'bam'}	1✔
122	helper = self._makeOne()	1✔
123	self.assertEqual(helper.authenticateCredentials(creds), (None, None))	1✔
124
125	def test_authenticateCredentials_w_mapping_known_remote_host(self):	1✔
126	creds = {'login': 'qux', 'remote_host': 'bam'}	1✔
127	helper = self._makeOne()	1✔
128	helper.manage_addMapping(match_type='equals', match_string='bam')	1✔
129
130	self.assertEqual(helper.authenticateCredentials(creds), ('qux', 'qux'))	1✔
131
132	def test_authenticateCredentials_w_mapping_known_remote_addr(self):	1✔
133	creds = {'login': 'qux', 'remote_address': 'baz'}	1✔
134	helper = self._makeOne()	1✔
135	helper.manage_addMapping(match_type='endswith', match_string='z',	1✔
136	username='foo')
137
138	self.assertEqual(helper.authenticateCredentials(creds), ('qux', 'qux'))	1✔
139
140	def test_authenticateCredentials_w_mapping_no_login_known_remote_hst(self):	1✔
141	creds = {'remote_host': 'baz'}	1✔
142	helper = self._makeOne()	1✔
143	helper.manage_addMapping(match_type='equals', match_string='baz',	1✔
144	username='foo')
145
146	self.assertEqual(helper.authenticateCredentials(creds), ('foo', 'foo'))	1✔
147
148	# ??? add tests for getRolesForPrincipal, etc.
149
150
151	class EqualsFilterTests(unittest.TestCase):	1✔
152
153	def _getTargetClass(self):	1✔
154	from ...plugins.DomainAuthHelper import EqualsFilter	1✔
155	return EqualsFilter	1✔
156
157	def _makeOne(self, matchstring):	1✔
158	return self._getTargetClass()(matchstring)	1✔
159
160	def test_hit(self):	1✔
161	filter = self._makeOne('hitme')	1✔
162	self.assertTrue(filter('hitme'))	1✔
163
164	def test_miss(self):	1✔
165	filter = self._makeOne('hitme')	1✔
166	self.assertFalse(filter('miss'))	1✔
167
168
169	class StartsWithFilterTests(unittest.TestCase):	1✔
170
171	def _getTargetClass(self):	1✔
172	from ...plugins.DomainAuthHelper import StartsWithFilter	1✔
173	return StartsWithFilter	1✔
174
175	def _makeOne(self, matchstring):	1✔
176	return self._getTargetClass()(matchstring)	1✔
177
178	def test_hit_exact(self):	1✔
179	filter = self._makeOne('hitme')	1✔
180	self.assertTrue(filter('hitme'))	1✔
181
182	def test_hit_prefix(self):	1✔
183	filter = self._makeOne('hit')	1✔
184	self.assertTrue(filter('hitme'))	1✔
185
186	def test_miss(self):	1✔
187	filter = self._makeOne('hitme')	1✔
188	self.assertFalse(filter('miss'))	1✔
189
190
191	class EndsWithFilterTests(unittest.TestCase):	1✔
192
193	def _getTargetClass(self):	1✔
194	from ...plugins.DomainAuthHelper import EndsWithFilter	1✔
195	return EndsWithFilter	1✔
196
197	def _makeOne(self, matchstring):	1✔
198	return self._getTargetClass()(matchstring)	1✔
199
200	def test_hit_exact(self):	1✔
201	filter = self._makeOne('hitme')	1✔
202	self.assertTrue(filter('hitme'))	1✔
203
204	def test_hit_suffix(self):	1✔
205	filter = self._makeOne('tme')	1✔
206	self.assertTrue(filter('hitme'))	1✔
207
208	def test_miss(self):	1✔
209	filter = self._makeOne('hitme')	1✔
210	self.assertFalse(filter('miss'))	1✔
211
212
213	class RegexFilterTests(unittest.TestCase):	1✔
214
215	def _getTargetClass(self):	1✔
216	from ...plugins.DomainAuthHelper import RegexFilter	1✔
217	return RegexFilter	1✔
218
219	def _makeOne(self, matchstring):	1✔
220	return self._getTargetClass()(matchstring)	1✔
221
222	def test_hit_exact(self):	1✔
223	filter = self._makeOne('^hitme$')	1✔
224	self.assertTrue(filter('hitme'))	1✔
225
226	def test_hit_pattern(self):	1✔
227	filter = self._makeOne('^h.*tme$')	1✔
228	self.assertTrue(filter('hitme'))	1✔
229
230	def test_miss(self):	1✔
231	filter = self._makeOne('^hitme$')	1✔
232	self.assertFalse(filter('miss'))	1✔
233
234
235	class IPFilterTests(unittest.TestCase):	1✔
236
237	def _getTargetClass(self):	1✔
238	from ...plugins.DomainAuthHelper import IPFilter	×
239	return IPFilter	×
240
241	def _makeOne(self, matchstring):	1✔
242	return self._getTargetClass()(matchstring)	×
243
244	def test_hit_exact(self):	1✔
245	filter = self._makeOne('192.168.1.24')	×
246	self.assertTrue(filter('192.168.1.24'))	×
247
248	def test_miss_exact(self):	1✔
249	filter = self._makeOne('192.168.1.24')	×
250	self.assertFalse(filter('192.168.1.13'))	×
251
252	def test_hit_prefix(self):	1✔
253	filter = self._makeOne('192.168.1.0/24')	×
254	self.assertTrue(filter('192.168.1.13'))	×
255
256	def test_miss_prefix(self):	1✔
257	filter = self._makeOne('192.168.1.0/24')	×
258	self.assertFalse(filter('192.168.0.13'))	×
259
260	def test_hit_range(self):	1✔
261	filter = self._makeOne('192.168.1.0-192.168.1.255')	×
262	self.assertTrue(filter('192.168.1.13'))	×
263
264	def test_miss_range(self):	1✔
265	filter = self._makeOne('192.168.1.0-192.168.1.255')	×
266	self.assertFalse(filter('192.168.0.13'))	×
267
268
269	def test_suite():	1✔
270	loadTestsFromTestCase = unittest.defaultTestLoader.loadTestsFromTestCase	1✔
271	tests = (loadTestsFromTestCase(DomainAuthHelperTests),	1✔
272	loadTestsFromTestCase(EqualsFilterTests),
273	loadTestsFromTestCase(StartsWithFilterTests),
274	loadTestsFromTestCase(EndsWithFilterTests),
275	loadTestsFromTestCase(RegexFilterTests))
276
277	if IP is not None:	1!
278	tests += (loadTestsFromTestCase(IPFilterTests),)	×
279
280	return unittest.TestSuite(tests)	1✔

zopefoundation / Products.PluggableAuthService / 5303493172

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