Package ldaptor :: Package test :: Module test_ldapfilter
[hide private]
[frames] | no frames]

Source Code for Module ldaptor.test.test_ldapfilter

  1  """ 
  2  Test cases for ldaptor.protocols.ldap.ldapfilter module. 
  3  """ 
  4   
  5  from twisted.trial import unittest 
  6  from ldaptor.protocols import pureldap 
  7  from ldaptor import ldapfilter 
  8  import types 
  9   
10 -def s(*l):
11 """Join all members of list to a string. Integer members are chr()ed""" 12 r='' 13 for e in l: 14 if isinstance(e, types.IntType): 15 e=chr(e) 16 r=r+str(e) 17 return r
18
19 -def l(s):
20 """Split a string to ord's of chars.""" 21 return map(lambda x: ord(x), s)
22
23 -class RFC2254Examples(unittest.TestCase):
24 - def test_cn(self):
25 text = '(cn=Babs Jensen)' 26 filt = pureldap.LDAPFilter_equalityMatch( 27 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 28 assertionValue=pureldap.LDAPAssertionValue(value='Babs Jensen')) 29 self.assertEquals(ldapfilter.parseFilter(text), filt) 30 self.assertEquals(filt.asText(), text)
31
32 - def test_not_cn(self):
33 text = '(!(cn=Tim Howes))' 34 filt = pureldap.LDAPFilter_not( 35 pureldap.LDAPFilter_equalityMatch( 36 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 37 assertionValue=pureldap.LDAPAssertionValue(value='Tim Howes'))) 38 self.assertEquals(ldapfilter.parseFilter(text), filt) 39 self.assertEquals(filt.asText(), text)
40
41 - def test_and_or(self):
42 text = '(&(objectClass=Person)(|(sn=Jensen)(cn=Babs J*)))' 43 filt = pureldap.LDAPFilter_and( 44 [ pureldap.LDAPFilter_equalityMatch( 45 attributeDesc=pureldap.LDAPAttributeDescription(value='objectClass'), 46 assertionValue=pureldap.LDAPAssertionValue(value='Person')), 47 pureldap.LDAPFilter_or([ pureldap.LDAPFilter_equalityMatch( 48 attributeDesc=pureldap.LDAPAttributeDescription(value='sn'), 49 assertionValue=pureldap.LDAPAssertionValue(value='Jensen')), 50 pureldap.LDAPFilter_substrings( 51 type='cn', 52 substrings=[ pureldap.LDAPFilter_substrings_initial(value='Babs J') 53 ]) 54 ]), 55 ]) 56 self.assertEquals(ldapfilter.parseFilter(text), filt) 57 self.assertEquals(filt.asText(), text)
58
59 - def test_substrings(self):
60 text = '(o=univ*of*mich*)' 61 filt = pureldap.LDAPFilter_substrings( 62 type='o', 63 substrings=[ pureldap.LDAPFilter_substrings_initial(value='univ'), 64 pureldap.LDAPFilter_substrings_any(value='of'), 65 pureldap.LDAPFilter_substrings_any(value='mich'), 66 ]) 67 self.assertEquals(ldapfilter.parseFilter(text), filt) 68 self.assertEquals(filt.asText(), text)
69 70
71 - def test_extensible_1(self):
72 text = '(cn:1.2.3.4.5:=Fred Flintstone)' 73 self.assertEquals(ldapfilter.parseFilter(text), 74 pureldap.LDAPFilter_extensibleMatch( 75 type='cn', 76 dnAttributes=False, 77 matchingRule='1.2.3.4.5', 78 matchValue='Fred Flintstone', 79 ))
80
81 - def test_extensible_2(self):
82 text = '(sn:dn:2.4.6.8.10:=Barney Rubble)' 83 self.assertEquals(ldapfilter.parseFilter(text), 84 pureldap.LDAPFilter_extensibleMatch( 85 type='sn', 86 dnAttributes=True, 87 matchingRule='2.4.6.8.10', 88 matchValue='Barney Rubble', 89 ))
90
91 - def test_extensible_3(self):
92 text = '(o:dn:=Ace Industry)' 93 self.assertEquals(ldapfilter.parseFilter(text), 94 pureldap.LDAPFilter_extensibleMatch( 95 type='o', 96 dnAttributes=True, 97 matchingRule=None, 98 matchValue='Ace Industry', 99 ))
100
101 - def test_extensible_4(self):
102 text = '(:dn:2.4.6.8.10:=Dino)' 103 self.assertEquals(ldapfilter.parseFilter(text), 104 pureldap.LDAPFilter_extensibleMatch( 105 type=None, 106 dnAttributes=True, 107 matchingRule='2.4.6.8.10', 108 matchValue='Dino', 109 ))
110
111 - def test_escape_parens(self):
112 text = r'(o=Parens R Us \28for all your parenthetical needs\29)' 113 filt = pureldap.LDAPFilter_equalityMatch( 114 attributeDesc=pureldap.LDAPAttributeDescription(value='o'), 115 assertionValue=pureldap.LDAPAssertionValue(value='Parens R Us (for all your parenthetical needs)')) 116 self.assertEquals(ldapfilter.parseFilter(text), filt) 117 self.assertEquals(filt.asText(), text)
118
119 - def test_escape_asterisk(self):
120 text = r'(cn=*\2A*)' 121 filt = pureldap.LDAPFilter_substrings( 122 type='cn', 123 substrings=[ pureldap.LDAPFilter_substrings_any(value='*'), 124 ]) 125 self.assertEquals(ldapfilter.parseFilter(text), filt) 126 self.assertEquals(filt.asText(), text.lower())
127
128 - def test_escape_backslash(self):
129 text = r'(filename=C:\5cMyFile)' 130 filt = pureldap.LDAPFilter_equalityMatch( 131 attributeDesc=pureldap.LDAPAttributeDescription(value='filename'), 132 assertionValue=pureldap.LDAPAssertionValue(value=r'C:\MyFile')) 133 self.assertEquals(ldapfilter.parseFilter(text), filt) 134 self.assertEquals(filt.asText(), text)
135
136 - def test_escape_binary(self):
137 text = r'(bin=\00\00\00\04)' 138 filt = pureldap.LDAPFilter_equalityMatch( 139 attributeDesc=pureldap.LDAPAttributeDescription(value='bin'), 140 assertionValue=pureldap.LDAPAssertionValue(value='\00\00\00\04')) 141 self.assertEquals(ldapfilter.parseFilter(text), filt)
142
143 - def test_escape_utf8(self):
144 text = r'(sn=Lu\c4\8di\c4\87)' 145 filt = pureldap.LDAPFilter_equalityMatch( 146 attributeDesc=pureldap.LDAPAttributeDescription(value='sn'), 147 assertionValue=pureldap.LDAPAssertionValue(value='Lu\xc4\x8di\xc4\x87')) 148 self.assertEquals(ldapfilter.parseFilter(text), filt)
149 #self.assertEquals(filt.asText(), text) 150
151 -class TestValid(unittest.TestCase):
152 - def test_item_present(self):
153 text = r'(cn=*)' 154 filt = pureldap.LDAPFilter_present(value='cn') 155 self.assertEquals(ldapfilter.parseFilter(text), filt) 156 self.assertEquals(filt.asText(), text)
157
158 - def test_item_simple(self):
159 text = r'(cn=foo)' 160 filt = pureldap.LDAPFilter_equalityMatch( 161 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 162 assertionValue=pureldap.LDAPAssertionValue(value='foo')) 163 self.assertEquals(ldapfilter.parseFilter(text), filt) 164 self.assertEquals(filt.asText(), text)
165
166 - def test_item_substring_init(self):
167 text = r'(cn=foo*)' 168 filt = pureldap.LDAPFilter_substrings( 169 type='cn', 170 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 171 ]) 172 self.assertEquals(ldapfilter.parseFilter(text), filt) 173 self.assertEquals(filt.asText(), text)
174
176 text = r'(cn=*foo)' 177 filt = pureldap.LDAPFilter_substrings( 178 type='cn', 179 substrings=[pureldap.LDAPFilter_substrings_final('foo'), 180 ]) 181 self.assertEquals(ldapfilter.parseFilter(text), filt) 182 self.assertEquals(filt.asText(), text)
183
184 - def test_item_substring_any(self):
185 text = r'(cn=*foo*)' 186 filt = pureldap.LDAPFilter_substrings( 187 type='cn', 188 substrings=[pureldap.LDAPFilter_substrings_any('foo'), 189 ]) 190 self.assertEquals(ldapfilter.parseFilter(text), filt) 191 self.assertEquals(filt.asText(), text)
192
193 - def test_item_substring_aa(self):
194 text = r'(cn=*foo*bar*)' 195 filt = pureldap.LDAPFilter_substrings( 196 type='cn', 197 substrings=[pureldap.LDAPFilter_substrings_any('foo'), 198 pureldap.LDAPFilter_substrings_any('bar'), 199 ]) 200 self.assertEquals(ldapfilter.parseFilter(text), filt) 201 self.assertEquals(filt.asText(), text)
202
203 - def test_item_substring_ia(self):
204 text = r'(cn=foo*bar*)' 205 filt = pureldap.LDAPFilter_substrings( 206 type='cn', 207 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 208 pureldap.LDAPFilter_substrings_any('bar'), 209 ]) 210 self.assertEquals(ldapfilter.parseFilter(text), filt) 211 self.assertEquals(filt.asText(), text)
212
213 - def test_item_substring_iaa(self):
214 text = r'(cn=foo*bar*baz*)' 215 filt = pureldap.LDAPFilter_substrings( 216 type='cn', 217 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 218 pureldap.LDAPFilter_substrings_any('bar'), 219 pureldap.LDAPFilter_substrings_any('baz'), 220 ]) 221 self.assertEquals(ldapfilter.parseFilter(text), filt) 222 self.assertEquals(filt.asText(), text)
223
224 - def test_item_substring_if(self):
225 text = r'(cn=foo*bar)' 226 filt = pureldap.LDAPFilter_substrings( 227 type='cn', 228 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 229 pureldap.LDAPFilter_substrings_final('bar'), 230 ]) 231 self.assertEquals(ldapfilter.parseFilter(text), filt) 232 self.assertEquals(filt.asText(), text)
233
234 - def test_item_substring_iaf(self):
235 text = r'(cn=foo*bar*baz)' 236 filt = pureldap.LDAPFilter_substrings( 237 type='cn', 238 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 239 pureldap.LDAPFilter_substrings_any('bar'), 240 pureldap.LDAPFilter_substrings_final('baz'), 241 ]) 242 self.assertEquals(ldapfilter.parseFilter(text), filt) 243 self.assertEquals(filt.asText(), text)
244
245 - def test_item_substring_iaaf(self):
246 text = r'(cn=foo*bar*baz*quux)' 247 filt = pureldap.LDAPFilter_substrings( 248 type='cn', 249 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 250 pureldap.LDAPFilter_substrings_any('bar'), 251 pureldap.LDAPFilter_substrings_any('baz'), 252 pureldap.LDAPFilter_substrings_final('quux'), 253 ]) 254 self.assertEquals(ldapfilter.parseFilter(text), filt) 255 self.assertEquals(filt.asText(), text)
256
257 - def test_item_substring_af(self):
258 text = r'(cn=*foo*bar)' 259 filt = pureldap.LDAPFilter_substrings( 260 type='cn', 261 substrings=[pureldap.LDAPFilter_substrings_any('foo'), 262 pureldap.LDAPFilter_substrings_final('bar'), 263 ]) 264 self.assertEquals(ldapfilter.parseFilter(text), filt) 265 self.assertEquals(filt.asText(), text)
266
267 - def test_item_substring_aaf(self):
268 text = r'(cn=*foo*bar*baz)' 269 filt = pureldap.LDAPFilter_substrings( 270 type='cn', 271 substrings=[pureldap.LDAPFilter_substrings_any('foo'), 272 pureldap.LDAPFilter_substrings_any('bar'), 273 pureldap.LDAPFilter_substrings_final('baz'), 274 ]) 275 self.assertEquals(ldapfilter.parseFilter(text), filt) 276 self.assertEquals(filt.asText(), text)
277
278 - def test_not_item(self):
279 text = r'(!(cn=foo))' 280 filt = pureldap.LDAPFilter_not( 281 pureldap.LDAPFilter_equalityMatch( 282 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 283 assertionValue=pureldap.LDAPAssertionValue(value='foo'))) 284 self.assertEquals(ldapfilter.parseFilter(text), filt) 285 self.assertEquals(filt.asText(), text)
286
287 - def test_or_item(self):
288 text = r'(|(cn=foo)(cn=bar))' 289 filt = pureldap.LDAPFilter_or([ 290 pureldap.LDAPFilter_equalityMatch( 291 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 292 assertionValue=pureldap.LDAPAssertionValue(value='foo')), 293 pureldap.LDAPFilter_equalityMatch( 294 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 295 assertionValue=pureldap.LDAPAssertionValue(value='bar')), 296 ]) 297 self.assertEquals(ldapfilter.parseFilter(text), filt) 298 self.assertEquals(filt.asText(), text)
299
300 - def test_and_item(self):
301 text = r'(&(cn=foo)(cn=bar))' 302 filt = pureldap.LDAPFilter_and([ 303 pureldap.LDAPFilter_equalityMatch( 304 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 305 assertionValue=pureldap.LDAPAssertionValue(value='foo')), 306 pureldap.LDAPFilter_equalityMatch( 307 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 308 assertionValue=pureldap.LDAPAssertionValue(value='bar')), 309 ]) 310 self.assertEquals(ldapfilter.parseFilter(text), filt) 311 self.assertEquals(filt.asText(), text)
312
313 - def test_andornot(self):
314 text = r'(&(!(|(cn=foo)(cn=bar)))(sn=a*b*c*d))' 315 filt = pureldap.LDAPFilter_and([ 316 pureldap.LDAPFilter_not( 317 pureldap.LDAPFilter_or([ 318 pureldap.LDAPFilter_equalityMatch( 319 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 320 assertionValue=pureldap.LDAPAssertionValue(value='foo')), 321 pureldap.LDAPFilter_equalityMatch( 322 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 323 assertionValue=pureldap.LDAPAssertionValue(value='bar')), 324 ])), 325 pureldap.LDAPFilter_substrings( 326 type='sn', 327 substrings=[pureldap.LDAPFilter_substrings_initial('a'), 328 pureldap.LDAPFilter_substrings_any('b'), 329 pureldap.LDAPFilter_substrings_any('c'), 330 pureldap.LDAPFilter_substrings_final('d'), 331 ])]) 332 self.assertEquals(ldapfilter.parseFilter(text), filt) 333 self.assertEquals(filt.asText(), text)
334
336 text = r'(cn=foo )' 337 filt = pureldap.LDAPFilter_equalityMatch( 338 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 339 assertionValue=pureldap.LDAPAssertionValue(value='foo ')) 340 self.assertEquals(ldapfilter.parseFilter(text), filt) 341 self.assertEquals(filt.asText(), text)
342 343
344 - def test_whitespace_afterEq(self):
345 text = r'(cn= foo)' 346 filt = pureldap.LDAPFilter_equalityMatch( 347 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 348 assertionValue=pureldap.LDAPAssertionValue(value=' foo')) 349 self.assertEquals(ldapfilter.parseFilter(text), filt) 350 self.assertEquals(filt.asText(), text)
351
352 -class TestInvalid(unittest.TestCase):
353 - def test_closeParen_1(self):
354 self.assertRaises(ldapfilter.InvalidLDAPFilter, 355 ldapfilter.parseFilter, 356 '(&(|(mail=)@*)(uid=)))(mail=*))')
357
358 - def test_closeParen_2(self):
359 self.assertRaises(ldapfilter.InvalidLDAPFilter, 360 ldapfilter.parseFilter, 361 '(|(mail=)@*)(uid=)))')
362
363 - def test_closeParen_3(self):
364 self.assertRaises(ldapfilter.InvalidLDAPFilter, 365 ldapfilter.parseFilter, 366 '(mail=)@*)')
367
368 - def test_closeParen_4(self):
369 self.assertRaises(ldapfilter.InvalidLDAPFilter, 370 ldapfilter.parseFilter, 371 '(uid=))')
372 373
374 - def test_openParen_1(self):
375 self.assertRaises(ldapfilter.InvalidLDAPFilter, 376 ldapfilter.parseFilter, 377 '(&(|(mail=(@*)(uid=())(mail=*))')
378
379 - def test_openParen_2(self):
380 self.assertRaises(ldapfilter.InvalidLDAPFilter, 381 ldapfilter.parseFilter, 382 '(|(mail=(@*)(uid=())')
383
384 - def test_openParen_3(self):
385 self.assertRaises(ldapfilter.InvalidLDAPFilter, 386 ldapfilter.parseFilter, 387 '(mail=(@*)')
388
389 - def test_openParen_4(self):
390 self.assertRaises(ldapfilter.InvalidLDAPFilter, 391 ldapfilter.parseFilter, 392 '(uid=()')
393
394 - def test_whitespace_leading(self):
395 self.assertRaises(ldapfilter.InvalidLDAPFilter, 396 ldapfilter.parseFilter, 397 r' (cn=foo)')
398
399 - def test_whitespace_trailing(self):
400 self.assertRaises(ldapfilter.InvalidLDAPFilter, 401 ldapfilter.parseFilter, 402 r'(cn=foo) ')
403
405 self.assertRaises(ldapfilter.InvalidLDAPFilter, 406 ldapfilter.parseFilter, 407 r'( cn=foo)')
408
409 - def test_whitespace_beforeEq(self):
410 self.assertRaises(ldapfilter.InvalidLDAPFilter, 411 ldapfilter.parseFilter, 412 r'(cn =foo)')
413
414 -class TestMaybeSubstring(unittest.TestCase):
415 - def test_item_present(self):
416 text = r'*' 417 filt = pureldap.LDAPFilter_present(value='cn') 418 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
419
420 - def test_item_simple(self):
421 text = r'foo' 422 filt = pureldap.LDAPFilter_equalityMatch( 423 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 424 assertionValue=pureldap.LDAPAssertionValue(value='foo')) 425 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
426
427 - def test_item_substring_init(self):
428 text = r'foo*' 429 filt = pureldap.LDAPFilter_substrings( 430 type='cn', 431 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 432 ]) 433 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
434
436 text = r'*foo' 437 filt = pureldap.LDAPFilter_substrings( 438 type='cn', 439 substrings=[pureldap.LDAPFilter_substrings_final('foo'), 440 ]) 441 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
442
443 - def test_item_substring_any(self):
444 text = r'*foo*' 445 filt = pureldap.LDAPFilter_substrings( 446 type='cn', 447 substrings=[pureldap.LDAPFilter_substrings_any('foo'), 448 ]) 449 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
450
451 - def test_item_substring_aa(self):
452 text = r'*foo*bar*' 453 filt = pureldap.LDAPFilter_substrings( 454 type='cn', 455 substrings=[pureldap.LDAPFilter_substrings_any('foo'), 456 pureldap.LDAPFilter_substrings_any('bar'), 457 ]) 458 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
459
460 - def test_item_substring_ia(self):
461 text = r'foo*bar*' 462 filt = pureldap.LDAPFilter_substrings( 463 type='cn', 464 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 465 pureldap.LDAPFilter_substrings_any('bar'), 466 ]) 467 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
468
469 - def test_item_substring_iaa(self):
470 text = r'foo*bar*baz*' 471 filt = pureldap.LDAPFilter_substrings( 472 type='cn', 473 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 474 pureldap.LDAPFilter_substrings_any('bar'), 475 pureldap.LDAPFilter_substrings_any('baz'), 476 ]) 477 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
478
479 - def test_item_substring_if(self):
480 text = r'foo*bar' 481 filt = pureldap.LDAPFilter_substrings( 482 type='cn', 483 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 484 pureldap.LDAPFilter_substrings_final('bar'), 485 ]) 486 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
487
488 - def test_item_substring_iaf(self):
489 text = r'foo*bar*baz' 490 filt = pureldap.LDAPFilter_substrings( 491 type='cn', 492 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 493 pureldap.LDAPFilter_substrings_any('bar'), 494 pureldap.LDAPFilter_substrings_final('baz'), 495 ]) 496 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
497
498 - def test_item_substring_iaaf(self):
499 text = r'foo*bar*baz*quux' 500 filt = pureldap.LDAPFilter_substrings( 501 type='cn', 502 substrings=[pureldap.LDAPFilter_substrings_initial('foo'), 503 pureldap.LDAPFilter_substrings_any('bar'), 504 pureldap.LDAPFilter_substrings_any('baz'), 505 pureldap.LDAPFilter_substrings_final('quux'), 506 ]) 507 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
508
509 - def test_item_substring_af(self):
510 text = r'*foo*bar' 511 filt = pureldap.LDAPFilter_substrings( 512 type='cn', 513 substrings=[pureldap.LDAPFilter_substrings_any('foo'), 514 pureldap.LDAPFilter_substrings_final('bar'), 515 ]) 516 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
517
518 - def test_item_substring_aaf(self):
519 text = r'*foo*bar*baz' 520 filt = pureldap.LDAPFilter_substrings( 521 type='cn', 522 substrings=[pureldap.LDAPFilter_substrings_any('foo'), 523 pureldap.LDAPFilter_substrings_any('bar'), 524 pureldap.LDAPFilter_substrings_final('baz'), 525 ]) 526 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
527
528 - def test_escape_simple(self):
529 text = r'f\2aoo(bar' 530 filt = pureldap.LDAPFilter_equalityMatch( 531 attributeDesc=pureldap.LDAPAttributeDescription(value='cn'), 532 assertionValue=pureldap.LDAPAssertionValue(value='f*oo(bar')) 533 self.assertEquals(ldapfilter.parseMaybeSubstring('cn', text), filt)
534
535 -class TestWhitespace(unittest.TestCase):
536 - def test_escape(self):
537 self.assertRaises(ldapfilter.InvalidLDAPFilter, 538 ldapfilter.parseFilter, 539 r'(cn=\ 61)')
540