| commit | author | age | ||
| 496fcf | 1 | import unittest |
| TS | 2 | |
| 9c1e6f | 3 | |
| 496fcf | 4 | class TestAuthTktCookiePlugin(unittest.TestCase): |
| 1810b2 | 5 | tempdir = None |
| 798feb | 6 | _now_testing = None |
| 1810b2 | 7 | |
| TS | 8 | def setUp(self): |
| 9 | pass | |
| 10 | ||
| 11 | def tearDown(self): | |
| 12 | if self.tempdir is not None: | |
| 13 | import shutil | |
| 14 | shutil.rmtree(self.tempdir) | |
| 798feb | 15 | if self._now_testing is not None: |
| TS | 16 | self._setNowTesting(self._now_testing) |
| 496fcf | 17 | |
| TS | 18 | def _getTargetClass(self): |
| 19 | from repoze.who.plugins.auth_tkt import AuthTktCookiePlugin | |
| 20 | return AuthTktCookiePlugin | |
| 21 | ||
| 22 | def _makeEnviron(self, kw=None): | |
| 02a504 | 23 | from wsgiref.util import setup_testing_defaults |
| AO | 24 | environ = {} |
| 25 | setup_testing_defaults(environ) | |
| 496fcf | 26 | if kw is not None: |
| TS | 27 | environ.update(kw) |
| 28 | environ['REMOTE_ADDR'] = '1.1.1.1' | |
| 02a504 | 29 | environ['HTTP_HOST'] = 'localhost' |
| 496fcf | 30 | return environ |
| TS | 31 | |
| b0f81f | 32 | def _makeOne(self, secret='s33kr3t', *arg, **kw): |
| TS | 33 | plugin = self._getTargetClass()(secret, *arg, **kw) |
| 496fcf | 34 | return plugin |
| TS | 35 | |
| 36 | def _makeTicket(self, userid='userid', remote_addr='0.0.0.0', | |
| 37 | tokens = [], userdata='userdata', | |
| cd1198 | 38 | cookie_name='auth_tkt', secure=False, |
| CM | 39 | time=None): |
| 02a504 | 40 | #from paste.auth import auth_tkt |
| AO | 41 | import repoze.who._auth_tkt as auth_tkt |
| 496fcf | 42 | ticket = auth_tkt.AuthTicket( |
| TS | 43 | 'secret', |
| 44 | userid, | |
| 45 | remote_addr, | |
| 46 | tokens=tokens, | |
| 47 | user_data=userdata, | |
| cd1198 | 48 | time=time, |
| 496fcf | 49 | cookie_name=cookie_name, |
| TS | 50 | secure=secure) |
| 51 | return ticket.cookie_value() | |
| 798feb | 52 | |
| TS | 53 | def _setNowTesting(self, value): |
| 54 | from repoze.who.plugins import auth_tkt | |
| 4f3525 | 55 | auth_tkt._UTCNOW, self._now_testing = value, auth_tkt._UTCNOW |
| 496fcf | 56 | |
| b0f81f | 57 | def test_class_conforms_to_IIdentifier(self): |
| 496fcf | 58 | from zope.interface.verify import verifyClass |
| TS | 59 | from repoze.who.interfaces import IIdentifier |
| 60 | klass = self._getTargetClass() | |
| 61 | verifyClass(IIdentifier, klass) | |
| b0f81f | 62 | |
| TS | 63 | def test_instance_conforms_to_IIdentifier(self): |
| 64 | from zope.interface.verify import verifyObject | |
| 65 | from repoze.who.interfaces import IIdentifier | |
| 66 | klass = self._getTargetClass() | |
| 67 | verifyObject(IIdentifier, self._makeOne()) | |
| 68 | ||
| 69 | def test_class_conforms_to_IAuthenticator(self): | |
| 70 | from zope.interface.verify import verifyClass | |
| 71 | from repoze.who.interfaces import IAuthenticator | |
| 72 | klass = self._getTargetClass() | |
| 73 | verifyClass(IAuthenticator, klass) | |
| 74 | ||
| 75 | def test_instance_conforms_to_IAuthenticator(self): | |
| 76 | from zope.interface.verify import verifyObject | |
| 77 | from repoze.who.interfaces import IAuthenticator | |
| 78 | klass = self._getTargetClass() | |
| 79 | verifyObject(IAuthenticator, self._makeOne()) | |
| 80 | ||
| 81 | def test_timeout_no_reissue(self): | |
| 82 | self.assertRaises(ValueError, self._makeOne, 'userid', timeout=1) | |
| 83 | ||
| 84 | def test_timeout_lower_than_reissue(self): | |
| 85 | self.assertRaises(ValueError, self._makeOne, 'userid', timeout=1, | |
| 86 | reissue_time=2) | |
| 496fcf | 87 | |
| TS | 88 | def test_identify_nocookie(self): |
| 89 | plugin = self._makeOne('secret') | |
| 90 | environ = self._makeEnviron() | |
| 91 | result = plugin.identify(environ) | |
| 92 | self.assertEqual(result, None) | |
| 93 | ||
| 94 | def test_identify_good_cookie_include_ip(self): | |
| 95 | plugin = self._makeOne('secret', include_ip=True) | |
| 96 | val = self._makeTicket(remote_addr='1.1.1.1') | |
| 97 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % val}) | |
| 98 | result = plugin.identify(environ) | |
| 99 | self.assertEqual(len(result), 4) | |
| 100 | self.assertEqual(result['tokens'], ['']) | |
| b0f81f | 101 | self.assertEqual(result['repoze.who.plugins.auth_tkt.userid'], 'userid') |
| 496fcf | 102 | self.assertEqual(result['userdata'], 'userdata') |
| 826ba0 | 103 | self.assertTrue('timestamp' in result) |
| 496fcf | 104 | self.assertEqual(environ['REMOTE_USER_TOKENS'], ['']) |
| TS | 105 | self.assertEqual(environ['REMOTE_USER_DATA'],'userdata') |
| 106 | self.assertEqual(environ['AUTH_TYPE'],'cookie') | |
| 107 | ||
| 108 | def test_identify_good_cookie_dont_include_ip(self): | |
| 109 | plugin = self._makeOne('secret', include_ip=False) | |
| 110 | val = self._makeTicket() | |
| 111 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % val}) | |
| 112 | result = plugin.identify(environ) | |
| 113 | self.assertEqual(len(result), 4) | |
| 114 | self.assertEqual(result['tokens'], ['']) | |
| b0f81f | 115 | self.assertEqual(result['repoze.who.plugins.auth_tkt.userid'], 'userid') |
| 496fcf | 116 | self.assertEqual(result['userdata'], 'userdata') |
| 826ba0 | 117 | self.assertTrue('timestamp' in result) |
| 496fcf | 118 | self.assertEqual(environ['REMOTE_USER_TOKENS'], ['']) |
| TS | 119 | self.assertEqual(environ['REMOTE_USER_DATA'],'userdata') |
| 120 | self.assertEqual(environ['AUTH_TYPE'],'cookie') | |
| 121 | ||
| 122 | def test_identify_good_cookie_int_useridtype(self): | |
| 123 | plugin = self._makeOne('secret', include_ip=False) | |
| 124 | val = self._makeTicket(userid='1', userdata='userid_type:int') | |
| 125 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % val}) | |
| 126 | result = plugin.identify(environ) | |
| 127 | self.assertEqual(len(result), 4) | |
| 128 | self.assertEqual(result['tokens'], ['']) | |
| b0f81f | 129 | self.assertEqual(result['repoze.who.plugins.auth_tkt.userid'], 1) |
| 496fcf | 130 | self.assertEqual(result['userdata'], 'userid_type:int') |
| 826ba0 | 131 | self.assertTrue('timestamp' in result) |
| 496fcf | 132 | self.assertEqual(environ['REMOTE_USER_TOKENS'], ['']) |
| TS | 133 | self.assertEqual(environ['REMOTE_USER_DATA'],'userid_type:int') |
| 134 | self.assertEqual(environ['AUTH_TYPE'],'cookie') | |
| 135 | ||
| 136 | def test_identify_good_cookie_unknown_useridtype(self): | |
| 137 | plugin = self._makeOne('secret', include_ip=False) | |
| 138 | val = self._makeTicket(userid='userid', userdata='userid_type:unknown') | |
| 139 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % val}) | |
| 140 | result = plugin.identify(environ) | |
| 141 | self.assertEqual(len(result), 4) | |
| 142 | self.assertEqual(result['tokens'], ['']) | |
| b0f81f | 143 | self.assertEqual(result['repoze.who.plugins.auth_tkt.userid'], 'userid') |
| 496fcf | 144 | self.assertEqual(result['userdata'], 'userid_type:unknown') |
| 826ba0 | 145 | self.assertTrue('timestamp' in result) |
| 496fcf | 146 | self.assertEqual(environ['REMOTE_USER_TOKENS'], ['']) |
| TS | 147 | self.assertEqual(environ['REMOTE_USER_DATA'],'userid_type:unknown') |
| 148 | self.assertEqual(environ['AUTH_TYPE'],'cookie') | |
| 149 | ||
| 150 | def test_identify_bad_cookie(self): | |
| 151 | plugin = self._makeOne('secret', include_ip=True) | |
| 152 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=bogus'}) | |
| 153 | result = plugin.identify(environ) | |
| 154 | self.assertEqual(result, None) | |
| 155 | ||
| cd1198 | 156 | def test_identify_bad_cookie_expired(self): |
| CM | 157 | import time |
| 158 | plugin = self._makeOne('secret', timeout=2, reissue_time=1) | |
| 159 | val = self._makeTicket(userid='userid', time=time.time()-3) | |
| 160 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % val}) | |
| 161 | result = plugin.identify(environ) | |
| 162 | self.assertEqual(result, None) | |
| b0f81f | 163 | |
| TS | 164 | def test_identify_with_checker_and_existing_account(self): |
| 165 | plugin = self._makeOne('secret', userid_checker=dummy_userid_checker) | |
| 166 | val = self._makeTicket(userid='existing') | |
| 167 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % val}) | |
| 168 | result = plugin.identify(environ) | |
| 169 | self.assertEqual(len(result), 4) | |
| 170 | self.assertEqual(result['tokens'], ['']) | |
| 171 | self.assertEqual(result['repoze.who.plugins.auth_tkt.userid'], 'existing') | |
| 172 | self.assertEqual(result['userdata'], 'userdata') | |
| 826ba0 | 173 | self.assertTrue('timestamp' in result) |
| b0f81f | 174 | self.assertEqual(environ['REMOTE_USER_TOKENS'], ['']) |
| TS | 175 | self.assertEqual(environ['REMOTE_USER_DATA'],'userdata') |
| 176 | self.assertEqual(environ['AUTH_TYPE'],'cookie') | |
| cd1198 | 177 | |
| 496fcf | 178 | def test_remember_creds_same(self): |
| TS | 179 | plugin = self._makeOne('secret') |
| 180 | val = self._makeTicket(userid='userid') | |
| 181 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % val}) | |
| 182 | result = plugin.remember(environ, {'repoze.who.userid':'userid', | |
| 183 | 'userdata':'userdata'}) | |
| 184 | self.assertEqual(result, None) | |
| 185 | ||
| d7e647 | 186 | def test_remember_creds_secure(self): |
| BS | 187 | plugin = self._makeOne('secret', secure=True) |
| 188 | val = self._makeTicket(userid='userid', secure=True) | |
| 189 | environ = self._makeEnviron() | |
| 190 | result = plugin.remember(environ, {'repoze.who.userid':'userid', | |
| 191 | 'userdata':'userdata'}) | |
| 192 | self.assertEqual(len(result), 3) | |
| 193 | self.assertEqual(result[0], | |
| 194 | ('Set-Cookie', | |
| 7f9907 | 195 | 'auth_tkt="%s"; ' |
| TS | 196 | 'Path=/; ' |
| 197 | 'secure; ' | |
| 198 | 'HttpOnly' % val)) | |
| d7e647 | 199 | self.assertEqual(result[1], |
| BS | 200 | ('Set-Cookie', |
| 7f9907 | 201 | 'auth_tkt="%s"; ' |
| TS | 202 | 'Path=/; ' |
| 203 | 'Domain=localhost; ' | |
| 204 | 'secure; HttpOnly' | |
| d7e647 | 205 | % val)) |
| BS | 206 | self.assertEqual(result[2], |
| 207 | ('Set-Cookie', | |
| 7f9907 | 208 | 'auth_tkt="%s"; ' |
| TS | 209 | 'Path=/; ' |
| 210 | 'Domain=.localhost; ' | |
| 211 | 'secure; HttpOnly' | |
| d7e647 | 212 | % val)) |
| BS | 213 | |
| 496fcf | 214 | def test_remember_creds_different(self): |
| TS | 215 | plugin = self._makeOne('secret') |
| 216 | old_val = self._makeTicket(userid='userid') | |
| 217 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % old_val}) | |
| 218 | new_val = self._makeTicket(userid='other', userdata='userdata') | |
| 219 | result = plugin.remember(environ, {'repoze.who.userid':'other', | |
| 220 | 'userdata':'userdata'}) | |
| 221 | self.assertEqual(len(result), 3) | |
| 222 | self.assertEqual(result[0], | |
| 223 | ('Set-Cookie', | |
| 7f9907 | 224 | 'auth_tkt="%s"; ' |
| TS | 225 | 'Path=/' % new_val)) |
| 496fcf | 226 | self.assertEqual(result[1], |
| TS | 227 | ('Set-Cookie', |
| 7f9907 | 228 | 'auth_tkt="%s"; ' |
| TS | 229 | 'Path=/; ' |
| 230 | 'Domain=localhost' | |
| 2afbb8 | 231 | % new_val)) |
| 496fcf | 232 | self.assertEqual(result[2], |
| TS | 233 | ('Set-Cookie', |
| 7f9907 | 234 | 'auth_tkt="%s"; ' |
| TS | 235 | 'Path=/; ' |
| 236 | 'Domain=.localhost' | |
| 237 | % new_val)) | |
| 238 | ||
| 239 | def test_remember_creds_different_strips_port(self): | |
| 240 | plugin = self._makeOne('secret') | |
| 241 | old_val = self._makeTicket(userid='userid') | |
| 242 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % old_val, | |
| 243 | 'HTTP_HOST': 'localhost:8080', | |
| 244 | }) | |
| 245 | new_val = self._makeTicket(userid='other', userdata='userdata') | |
| 246 | result = plugin.remember(environ, {'repoze.who.userid':'other', | |
| 247 | 'userdata':'userdata'}) | |
| 248 | self.assertEqual(len(result), 3) | |
| 249 | self.assertEqual(result[0], | |
| 250 | ('Set-Cookie', | |
| 251 | 'auth_tkt="%s"; ' | |
| 252 | 'Path=/' % new_val)) | |
| 253 | self.assertEqual(result[1], | |
| 254 | ('Set-Cookie', | |
| 255 | 'auth_tkt="%s"; ' | |
| 256 | 'Path=/; ' | |
| 257 | 'Domain=localhost' | |
| 258 | % new_val)) | |
| 259 | self.assertEqual(result[2], | |
| 260 | ('Set-Cookie', | |
| 261 | 'auth_tkt="%s"; ' | |
| 262 | 'Path=/; ' | |
| 263 | 'Domain=.localhost' | |
| 2afbb8 | 264 | % new_val)) |
| 496fcf | 265 | |
| 394ea6 | 266 | def test_remember_creds_different_include_ip(self): |
| TS | 267 | plugin = self._makeOne('secret', include_ip=True) |
| 268 | old_val = self._makeTicket(userid='userid', remote_addr='1.1.1.1') | |
| 269 | environ = self._makeEnviron({'HTTP_COOKIE': 'auth_tkt=%s' % old_val}) | |
| 270 | new_val = self._makeTicket(userid='other', | |
| 271 | userdata='userdata', | |
| 272 | remote_addr='1.1.1.1') | |
| 273 | result = plugin.remember(environ, {'repoze.who.userid':'other', | |
| 274 | 'userdata':'userdata'}) | |
| 275 | self.assertEqual(len(result), 3) | |
| 276 | self.assertEqual(result[0], | |
| 277 | ('Set-Cookie', | |
| 7f9907 | 278 | 'auth_tkt="%s"; ' |
| TS | 279 | 'Path=/' % new_val)) |
| 394ea6 | 280 | self.assertEqual(result[1], |
| TS | 281 | ('Set-Cookie', |
| 7f9907 | 282 | 'auth_tkt="%s"; ' |
| TS | 283 | 'Path=/; ' |
| 284 | 'Domain=localhost' | |
| 394ea6 | 285 | % new_val)) |
| TS | 286 | self.assertEqual(result[2], |
| 287 | ('Set-Cookie', | |
| 7f9907 | 288 | 'auth_tkt="%s"; ' |
| TS | 289 | 'Path=/; ' |
| 290 | 'Domain=.localhost' | |
| 394ea6 | 291 | % new_val)) |
| TS | 292 | |
| 293 | def test_remember_creds_different_bad_old_cookie(self): | |
| 294 | plugin = self._makeOne('secret') | |
| 295 | old_val = 'BOGUS' | |
| 296 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % old_val}) | |
| 297 | new_val = self._makeTicket(userid='other', userdata='userdata') | |
| 298 | result = plugin.remember(environ, {'repoze.who.userid':'other', | |
| 299 | 'userdata':'userdata'}) | |
| 300 | self.assertEqual(len(result), 3) | |
| 301 | self.assertEqual(result[0], | |
| 302 | ('Set-Cookie', | |
| 7f9907 | 303 | 'auth_tkt="%s"; ' |
| TS | 304 | 'Path=/' % new_val)) |
| 394ea6 | 305 | self.assertEqual(result[1], |
| TS | 306 | ('Set-Cookie', |
| 7f9907 | 307 | 'auth_tkt="%s"; ' |
| TS | 308 | 'Path=/; ' |
| 309 | 'Domain=localhost' | |
| 394ea6 | 310 | % new_val)) |
| TS | 311 | self.assertEqual(result[2], |
| 312 | ('Set-Cookie', | |
| 7f9907 | 313 | 'auth_tkt="%s"; ' |
| TS | 314 | 'Path=/; ' |
| 315 | 'Domain=.localhost' | |
| 394ea6 | 316 | % new_val)) |
| TS | 317 | |
| fc9a88 | 318 | def test_remember_creds_different_with_tokens(self): |
| 394ea6 | 319 | plugin = self._makeOne('secret') |
| TS | 320 | old_val = self._makeTicket(userid='userid') |
| 321 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % old_val}) | |
| fc9a88 | 322 | new_val = self._makeTicket(userid='userid', |
| 394ea6 | 323 | userdata='userdata', |
| fc9a88 | 324 | tokens=['foo', 'bar'], |
| 394ea6 | 325 | ) |
| fc9a88 | 326 | result = plugin.remember(environ, {'repoze.who.userid': 'userid', |
| 394ea6 | 327 | 'userdata': 'userdata', |
| TS | 328 | 'tokens': ['foo', 'bar'], |
| 329 | }) | |
| 330 | self.assertEqual(len(result), 3) | |
| 331 | self.assertEqual(result[0], | |
| 332 | ('Set-Cookie', | |
| 7f9907 | 333 | 'auth_tkt="%s"; ' |
| TS | 334 | 'Path=/' % new_val)) |
| 394ea6 | 335 | self.assertEqual(result[1], |
| TS | 336 | ('Set-Cookie', |
| 7f9907 | 337 | 'auth_tkt="%s"; ' |
| TS | 338 | 'Path=/; Domain=localhost' |
| 394ea6 | 339 | % new_val)) |
| TS | 340 | self.assertEqual(result[2], |
| 341 | ('Set-Cookie', | |
| 7f9907 | 342 | 'auth_tkt="%s"; ' |
| TS | 343 | 'Path=/; ' |
| 344 | 'Domain=.localhost' | |
| 394ea6 | 345 | % new_val)) |
| TS | 346 | |
| fc9a88 | 347 | def test_remember_creds_different_with_tuple_tokens(self): |
| BS | 348 | plugin = self._makeOne('secret') |
| 349 | old_val = self._makeTicket(userid='userid') | |
| 350 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % old_val}) | |
| 351 | new_val = self._makeTicket(userid='userid', | |
| 352 | userdata='userdata', | |
| 353 | tokens=['foo', 'bar'], | |
| 354 | ) | |
| 355 | result = plugin.remember(environ, {'repoze.who.userid': 'userid', | |
| 356 | 'userdata': 'userdata', | |
| 357 | 'tokens': ('foo', 'bar'), | |
| 358 | }) | |
| 359 | self.assertEqual(len(result), 3) | |
| 360 | self.assertEqual(result[0], | |
| 361 | ('Set-Cookie', | |
| 7f9907 | 362 | 'auth_tkt="%s"; ' |
| TS | 363 | 'Path=/' % new_val)) |
| fc9a88 | 364 | self.assertEqual(result[1], |
| BS | 365 | ('Set-Cookie', |
| 7f9907 | 366 | 'auth_tkt="%s"; ' |
| TS | 367 | 'Path=/; ' |
| 368 | 'Domain=localhost' | |
| fc9a88 | 369 | % new_val)) |
| BS | 370 | self.assertEqual(result[2], |
| 371 | ('Set-Cookie', | |
| 7f9907 | 372 | 'auth_tkt="%s"; ' |
| TS | 373 | 'Path=/; ' |
| 374 | 'Domain=.localhost' | |
| fc9a88 | 375 | % new_val)) |
| BS | 376 | |
| 496fcf | 377 | def test_remember_creds_different_int_userid(self): |
| TS | 378 | plugin = self._makeOne('secret') |
| 379 | old_val = self._makeTicket(userid='userid') | |
| 380 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % old_val}) | |
| 381 | new_val = self._makeTicket(userid='1', userdata='userid_type:int') | |
| 382 | result = plugin.remember(environ, {'repoze.who.userid':1, | |
| 383 | 'userdata':''}) | |
| 384 | ||
| 385 | self.assertEqual(len(result), 3) | |
| 386 | self.assertEqual(result[0], | |
| 387 | ('Set-Cookie', | |
| d6fa0a | 388 | 'auth_tkt="%s"; Path=/' % new_val)) |
| 496fcf | 389 | |
| TS | 390 | def test_remember_creds_different_long_userid(self): |
| 6a32cd | 391 | try: |
| TS | 392 | long |
| 393 | except NameError: #pragma NO COVER Python >= 3.0 | |
| 394 | return | |
| 496fcf | 395 | plugin = self._makeOne('secret') |
| TS | 396 | old_val = self._makeTicket(userid='userid') |
| 397 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % old_val}) | |
| 398 | new_val = self._makeTicket(userid='1', userdata='userid_type:int') | |
| 399 | result = plugin.remember(environ, {'repoze.who.userid':long(1), | |
| 400 | 'userdata':''}) | |
| 401 | self.assertEqual(len(result), 3) | |
| 402 | self.assertEqual(result[0], | |
| 403 | ('Set-Cookie', | |
| d6fa0a | 404 | 'auth_tkt="%s"; Path=/' % new_val)) |
| 496fcf | 405 | |
| TS | 406 | def test_remember_creds_different_unicode_userid(self): |
| 407 | plugin = self._makeOne('secret') | |
| 408 | old_val = self._makeTicket(userid='userid') | |
| 409 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % old_val}) | |
| 6a32cd | 410 | userid = b'\xc2\xa9'.decode('utf-8') |
| d6fa0a | 411 | if type(b'') == type(''): |
| TS | 412 | userdata = 'userid_type:unicode' |
| d13829 | 413 | else: # pragma: no cover Py3k |
| d6fa0a | 414 | userdata = '' |
| 496fcf | 415 | new_val = self._makeTicket(userid=userid.encode('utf-8'), |
| d6fa0a | 416 | userdata=userdata) |
| 496fcf | 417 | result = plugin.remember(environ, {'repoze.who.userid':userid, |
| TS | 418 | 'userdata':''}) |
| 419 | self.assertEqual(type(result[0][1]), str) | |
| 420 | self.assertEqual(len(result), 3) | |
| 421 | self.assertEqual(result[0], | |
| 422 | ('Set-Cookie', | |
| d6fa0a | 423 | 'auth_tkt="%s"; Path=/' % new_val)) |
| 496fcf | 424 | |
| cd1198 | 425 | def test_remember_creds_reissue(self): |
| CM | 426 | import time |
| 427 | plugin = self._makeOne('secret', reissue_time=1) | |
| 798feb | 428 | old_val = self._makeTicket(userid='userid', userdata='', |
| TS | 429 | time=time.time()-2) |
| cd1198 | 430 | environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=%s' % old_val}) |
| CM | 431 | new_val = self._makeTicket(userid='userid', userdata='') |
| 432 | result = plugin.remember(environ, {'repoze.who.userid':'userid', | |
| 433 | 'userdata':''}) | |
| 434 | self.assertEqual(type(result[0][1]), str) | |
| 435 | self.assertEqual(len(result), 3) | |
| 436 | self.assertEqual(result[0], | |
| 437 | ('Set-Cookie', | |
| d6fa0a | 438 | 'auth_tkt="%s"; Path=/' % new_val)) |
| cd1198 | 439 | |
| 4f3525 | 440 | def test_l10n_sane_cookie_date(self): |
| TS | 441 | from datetime import datetime |
| 442 | ||
| 443 | now = datetime(2009, 11, 8, 16, 15, 22) | |
| 444 | self._setNowTesting(now) | |
| 445 | ||
| b0f81f | 446 | plugin = self._makeOne('secret') |
| 4f3525 | 447 | environ = {'HTTP_HOST': 'example.com'} |
| TS | 448 | |
| b0f81f | 449 | tkt = self._makeTicket(userid='chris', userdata='') |
| 4f3525 | 450 | |
| TS | 451 | |
| 452 | result = plugin.remember(environ, {'repoze.who.userid': 'chris', | |
| 453 | 'max_age': '500'}) | |
| 454 | name, value = result.pop(0) | |
| 455 | ||
| 456 | self.assertEqual('Set-Cookie', name) | |
| 826ba0 | 457 | self.assertTrue( |
| 4f3525 | 458 | value.endswith('; Expires=Sun, 08 Nov 2009 16:23:42 GMT')) |
| TS | 459 | |
| 460 | def test_remember_max_age(self): | |
| 461 | from datetime import datetime | |
| 462 | ||
| 463 | now = datetime(2009, 11, 8, 16, 15, 22) | |
| 464 | self._setNowTesting(now) | |
| 465 | ||
| 466 | plugin = self._makeOne('secret') | |
| 467 | environ = {'HTTP_HOST': 'example.com'} | |
| 468 | ||
| 469 | tkt = self._makeTicket(userid='chris', userdata='') | |
| 470 | result = plugin.remember(environ, {'repoze.who.userid': 'chris', | |
| 471 | 'max_age': '500'}) | |
| 472 | ||
| 473 | name, value = result.pop(0) | |
| b0f81f | 474 | self.assertEqual('Set-Cookie', name) |
| 826ba0 | 475 | self.assertTrue( |
| b0f81f | 476 | value.startswith('auth_tkt="%s"; Path=/; Max-Age=500' % tkt), |
| TS | 477 | value) |
| 826ba0 | 478 | self.assertTrue( |
| 4f3525 | 479 | value.endswith('; Expires=Sun, 08 Nov 2009 16:23:42 GMT')) |
| b0f81f | 480 | |
| 4f3525 | 481 | name, value = result.pop(0) |
| b0f81f | 482 | self.assertEqual('Set-Cookie', name) |
| 826ba0 | 483 | self.assertTrue( |
| b0f81f | 484 | value.startswith( |
| 4f3525 | 485 | 'auth_tkt="%s"; Path=/; Domain=example.com; Max-Age=500' |
| TS | 486 | % tkt), value) |
| 826ba0 | 487 | self.assertTrue( |
| 4f3525 | 488 | value.endswith('; Expires=Sun, 08 Nov 2009 16:23:42 GMT')) |
| TS | 489 | |
| 490 | name, value = result.pop(0) | |
| 491 | self.assertEqual('Set-Cookie', name) | |
| 826ba0 | 492 | self.assertTrue( |
| 4f3525 | 493 | value.startswith( |
| TS | 494 | 'auth_tkt="%s"; Path=/; Domain=.example.com; Max-Age=500' % tkt), |
| b0f81f | 495 | value) |
| 826ba0 | 496 | self.assertTrue( |
| 4f3525 | 497 | value.endswith('; Expires=Sun, 08 Nov 2009 16:23:42 GMT')) |
| b0f81f | 498 | |
| 496fcf | 499 | def test_forget(self): |
| 798feb | 500 | from datetime import datetime |
| TS | 501 | now = datetime(2009, 11, 5, 16, 15, 22) |
| 502 | self._setNowTesting(now) | |
| 496fcf | 503 | plugin = self._makeOne('secret') |
| TS | 504 | environ = self._makeEnviron() |
| 505 | headers = plugin.forget(environ, None) | |
| 506 | self.assertEqual(len(headers), 3) | |
| 507 | header = headers[0] | |
| 508 | name, value = header | |
| 509 | self.assertEqual(name, 'Set-Cookie') | |
| 798feb | 510 | self.assertEqual(value, |
| TS | 511 | 'auth_tkt="INVALID"; Path=/; ' |
| 4f3525 | 512 | 'Max-Age=0; Expires=Thu, 05 Nov 2009 16:15:22 GMT' |
| 798feb | 513 | ) |
| 496fcf | 514 | header = headers[1] |
| TS | 515 | name, value = header |
| 516 | self.assertEqual(name, 'Set-Cookie') | |
| 798feb | 517 | self.assertEqual(value, |
| TS | 518 | 'auth_tkt="INVALID"; Path=/; Domain=localhost; ' |
| 4f3525 | 519 | 'Max-Age=0; Expires=Thu, 05 Nov 2009 16:15:22 GMT' |
| 798feb | 520 | ) |
| 496fcf | 521 | header = headers[2] |
| TS | 522 | name, value = header |
| 523 | self.assertEqual(name, 'Set-Cookie') | |
| 798feb | 524 | self.assertEqual(value, |
| TS | 525 | 'auth_tkt="INVALID"; Path=/; Domain=.localhost; ' |
| 4f3525 | 526 | 'Max-Age=0; Expires=Thu, 05 Nov 2009 16:15:22 GMT' |
| 798feb | 527 | ) |
| b0f81f | 528 | |
| TS | 529 | def test_authenticate_non_auth_tkt_credentials(self): |
| 530 | plugin = self._makeOne() | |
| 531 | self.assertEqual(plugin.authenticate(environ={}, identity={}), None) | |
| 532 | ||
| 533 | def test_authenticate_without_checker(self): | |
| 534 | plugin = self._makeOne() | |
| 535 | identity = {'repoze.who.plugins.auth_tkt.userid': 'phred'} | |
| 536 | self.assertEqual(plugin.authenticate({}, identity), 'phred') | |
| 537 | ||
| 538 | def test_authenticate_with_checker_and_non_existing_account(self): | |
| 539 | plugin = self._makeOne('secret', userid_checker=dummy_userid_checker) | |
| 540 | identity = {'repoze.who.plugins.auth_tkt.userid': 'phred'} | |
| 541 | self.assertEqual(plugin.authenticate({}, identity), None) | |
| 542 | ||
| 543 | def test_authenticate_with_checker_and_existing_account(self): | |
| 544 | plugin = self._makeOne('secret', userid_checker=dummy_userid_checker) | |
| 545 | identity = {'repoze.who.plugins.auth_tkt.userid': 'existing'} | |
| 546 | self.assertEqual(plugin.authenticate({}, identity), 'existing') | |
| 496fcf | 547 | |
| TS | 548 | def test_factory_wo_secret_wo_secretfile_raises_ValueError(self): |
| 549 | from repoze.who.plugins.auth_tkt import make_plugin | |
| 550 | self.assertRaises(ValueError, make_plugin) | |
| 551 | ||
| 552 | def test_factory_w_secret_w_secretfile_raises_ValueError(self): | |
| 553 | from repoze.who.plugins.auth_tkt import make_plugin | |
| 554 | self.assertRaises(ValueError, make_plugin, 'secret', 'secretfile') | |
| 555 | ||
| 556 | def test_factory_w_bad_secretfile_raises_ValueError(self): | |
| 557 | from repoze.who.plugins.auth_tkt import make_plugin | |
| 558 | self.assertRaises(ValueError, make_plugin, secretfile='nonesuch.txt') | |
| 559 | ||
| 560 | def test_factory_w_secret(self): | |
| 561 | from repoze.who.plugins.auth_tkt import make_plugin | |
| 562 | plugin = make_plugin('secret') | |
| 563 | self.assertEqual(plugin.cookie_name, 'auth_tkt') | |
| 564 | self.assertEqual(plugin.secret, 'secret') | |
| 565 | self.assertEqual(plugin.include_ip, False) | |
| 566 | self.assertEqual(plugin.secure, False) | |
| 567 | ||
| 568 | def test_factory_w_secretfile(self): | |
| 1810b2 | 569 | import os |
| TS | 570 | from tempfile import mkdtemp |
| 496fcf | 571 | from repoze.who.plugins.auth_tkt import make_plugin |
| 1810b2 | 572 | tempdir = self.tempdir = mkdtemp() |
| TS | 573 | path = os.path.join(tempdir, 'who.secret') |
| 574 | secret = open(path, 'w') | |
| 575 | secret.write('s33kr1t\n') | |
| 576 | secret.flush() | |
| 577 | secret.close() | |
| 578 | plugin = make_plugin(secretfile=path) | |
| 496fcf | 579 | self.assertEqual(plugin.secret, 's33kr1t') |
| TS | 580 | |
| cd1198 | 581 | def test_factory_with_timeout_and_reissue_time(self): |
| CM | 582 | from repoze.who.plugins.auth_tkt import make_plugin |
| 583 | plugin = make_plugin('secret', timeout=5, reissue_time=1) | |
| 584 | self.assertEqual(plugin.timeout, 5) | |
| 585 | self.assertEqual(plugin.reissue_time, 1) | |
| 586 | ||
| a6f6dc | 587 | def test_factory_with_userid_checker(self): |
| CM | 588 | from repoze.who.plugins.auth_tkt import make_plugin |
| 589 | plugin = make_plugin( | |
| 590 | 'secret', | |
| 591 | userid_checker='repoze.who.plugins.auth_tkt:make_plugin') | |
| 592 | self.assertEqual(plugin.userid_checker, make_plugin) | |
| 299b4c | 593 | |
| 15e365 | 594 | def test_remember_max_age_unicode(self): |
| 6a32cd | 595 | from repoze.who._compat import u |
| 15e365 | 596 | plugin = self._makeOne('secret') |
| TS | 597 | environ = {'HTTP_HOST':'example.com'} |
| 598 | tkt = self._makeTicket(userid='chris', userdata='') | |
| 599 | result = plugin.remember(environ, {'repoze.who.userid': 'chris', | |
| 6919cb | 600 | 'max_age': u('500')}) |
| TS | 601 | name, value = result.pop(0) |
| 15e365 | 602 | self.assertEqual('Set-Cookie', name) |
| 826ba0 | 603 | self.assertTrue(isinstance(value, str)) |
| TS | 604 | self.assertTrue( |
| 15e365 | 605 | value.startswith('auth_tkt="%s"; Path=/; Max-Age=500' % tkt), |
| TS | 606 | (value, tkt)) |
| 826ba0 | 607 | self.assertTrue('; Expires=' in value) |
| 15e365 | 608 | |
| TS | 609 | name,value = result.pop(0) |
| 610 | self.assertEqual('Set-Cookie', name) | |
| 826ba0 | 611 | self.assertTrue( |
| 15e365 | 612 | value.startswith( |
| TS | 613 | 'auth_tkt="%s"; Path=/; Domain=example.com; Max-Age=500' |
| 614 | % tkt), value) | |
| 826ba0 | 615 | self.assertTrue('; Expires=' in value) |
| 15e365 | 616 | |
| TS | 617 | name,value = result.pop(0) |
| 618 | self.assertEqual('Set-Cookie', name) | |
| 826ba0 | 619 | self.assertTrue( |
| 15e365 | 620 | value.startswith( |
| TS | 621 | 'auth_tkt="%s"; Path=/; Domain=.example.com; Max-Age=500' % tkt), |
| 622 | value) | |
| 826ba0 | 623 | self.assertTrue('; Expires=' in value) |
| 15e365 | 624 | |
| 299b4c | 625 | |
| a6f6dc | 626 | def dummy_userid_checker(userid): |
| CM | 627 | return userid == 'existing' |
