Package lxml :: Package tests :: Module test_objectify
[hide private]
[frames] | no frames]

Source Code for Module lxml.tests.test_objectify

   1  # -*- coding: utf-8 -*- 
   2   
   3  """ 
   4  Tests specific to the lxml.objectify API 
   5  """ 
   6   
   7   
   8  import unittest, operator, sys, os.path 
   9   
  10  this_dir = os.path.dirname(__file__) 
  11  if this_dir not in sys.path: 
  12      sys.path.insert(0, this_dir) # needed for Py3 
  13   
  14  from common_imports import etree, HelperTestCase, fileInTestDir 
  15  from common_imports import SillyFileLike, canonicalize, doctest, make_doctest 
  16  from common_imports import _bytes, _str, StringIO, BytesIO 
  17   
  18  from lxml import objectify 
  19   
  20  PYTYPE_NAMESPACE = "http://codespeak.net/lxml/objectify/pytype" 
  21  XML_SCHEMA_NS = "http://www.w3.org/2001/XMLSchema" 
  22  XML_SCHEMA_INSTANCE_NS = "http://www.w3.org/2001/XMLSchema-instance" 
  23  XML_SCHEMA_INSTANCE_TYPE_ATTR = "{%s}type" % XML_SCHEMA_INSTANCE_NS 
  24  XML_SCHEMA_NIL_ATTR = "{%s}nil" % XML_SCHEMA_INSTANCE_NS 
  25  TREE_PYTYPE = "TREE" 
  26  DEFAULT_NSMAP = { "py"  : PYTYPE_NAMESPACE, 
  27                    "xsi" : XML_SCHEMA_INSTANCE_NS, 
  28                    "xsd" : XML_SCHEMA_NS} 
  29   
  30  objectclass2xsitype = { 
  31      # objectify built-in 
  32      objectify.IntElement: ("int", "short", "byte", "unsignedShort", 
  33                             "unsignedByte", "integer", "nonPositiveInteger", 
  34                             "negativeInteger", "long", "nonNegativeInteger", 
  35                             "unsignedLong", "unsignedInt", "positiveInteger",), 
  36      objectify.FloatElement: ("float", "double"), 
  37      objectify.BoolElement: ("boolean",), 
  38      objectify.StringElement: ("string", "normalizedString", "token", "language", 
  39                                "Name", "NCName", "ID", "IDREF", "ENTITY", 
  40                                "NMTOKEN", ), 
  41      # None: xsi:nil="true" 
  42      } 
  43   
  44  xsitype2objclass = dict([ (v, k) for k in objectclass2xsitype 
  45                            for v in objectclass2xsitype[k] ]) 
  46   
  47  objectclass2pytype = { 
  48      # objectify built-in 
  49      objectify.IntElement: "int", 
  50      objectify.FloatElement: "float", 
  51      objectify.BoolElement: "bool", 
  52      objectify.StringElement: "str", 
  53      # None: xsi:nil="true" 
  54      } 
  55   
  56  pytype2objclass = dict([ (objectclass2pytype[k], k) 
  57                           for k in objectclass2pytype]) 
  58   
  59  xml_str = '''\ 
  60  <obj:root xmlns:obj="objectified" xmlns:other="otherNS"> 
  61    <obj:c1 a1="A1" a2="A2" other:a3="A3"> 
  62      <obj:c2>0</obj:c2> 
  63      <obj:c2>1</obj:c2> 
  64      <obj:c2>2</obj:c2> 
  65      <other:c2>3</other:c2> 
  66      <c2>3</c2> 
  67    </obj:c1> 
  68  </obj:root>''' 
  69   
70 -class ObjectifyTestCase(HelperTestCase):
71 """Test cases for lxml.objectify 72 """ 73 etree = etree 74
75 - def XML(self, xml):
76 return self.etree.XML(xml, self.parser)
77
78 - def setUp(self):
79 super(ObjectifyTestCase, self).setUp() 80 self.parser = self.etree.XMLParser(remove_blank_text=True) 81 self.lookup = etree.ElementNamespaceClassLookup( 82 objectify.ObjectifyElementClassLookup() ) 83 self.parser.set_element_class_lookup(self.lookup) 84 85 self.Element = self.parser.makeelement 86 87 ns = self.lookup.get_namespace("otherNS") 88 ns[None] = self.etree.ElementBase 89 90 self._orig_types = objectify.getRegisteredTypes()
91
92 - def tearDown(self):
93 self.lookup.get_namespace("otherNS").clear() 94 objectify.set_pytype_attribute_tag() 95 del self.lookup 96 del self.parser 97 98 for pytype in objectify.getRegisteredTypes(): 99 pytype.unregister() 100 for pytype in self._orig_types: 101 pytype.register() 102 del self._orig_types 103 104 super(ObjectifyTestCase, self).tearDown()
105 106
107 - def test_element_nsmap_default(self):
108 elt = objectify.Element("test") 109 self.assertEquals(elt.nsmap, DEFAULT_NSMAP)
110
111 - def test_element_nsmap_empty(self):
112 nsmap = {} 113 elt = objectify.Element("test", nsmap=nsmap) 114 self.assertEquals(list(elt.nsmap.values()), [PYTYPE_NAMESPACE])
115
117 nsmap = {"mypy": PYTYPE_NAMESPACE, 118 "myxsi": XML_SCHEMA_INSTANCE_NS, 119 "myxsd": XML_SCHEMA_NS} 120 elt = objectify.Element("test", nsmap=nsmap) 121 self.assertEquals(elt.nsmap, nsmap)
122
123 - def test_element_nsmap_custom(self):
124 nsmap = {"my": "someNS", 125 "myother": "someOtherNS", 126 "myxsd": XML_SCHEMA_NS} 127 elt = objectify.Element("test", nsmap=nsmap) 128 self.assert_(PYTYPE_NAMESPACE in elt.nsmap.values()) 129 for prefix, ns in nsmap.items(): 130 self.assert_(prefix in elt.nsmap) 131 self.assertEquals(nsmap[prefix], elt.nsmap[prefix])
132
134 root = objectify.Element("root") 135 root.sub = objectify.Element("test") 136 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)
137
139 root = objectify.Element("root") 140 nsmap = {} 141 root.sub = objectify.Element("test", nsmap=nsmap) 142 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)
143
145 root = objectify.Element("root") 146 nsmap = {"mypy": PYTYPE_NAMESPACE, 147 "myxsi": XML_SCHEMA_INSTANCE_NS, 148 "myxsd": XML_SCHEMA_NS} 149 root.sub = objectify.Element("test", nsmap=nsmap) 150 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)
151
153 root = objectify.Element("root") 154 nsmap = {"my": "someNS", 155 "myother": "someOtherNS", 156 "myxsd": XML_SCHEMA_NS,} 157 root.sub = objectify.Element("test", nsmap=nsmap) 158 expected = nsmap.copy() 159 del expected["myxsd"] 160 expected.update(DEFAULT_NSMAP) 161 self.assertEquals(root.sub.nsmap, expected)
162
164 value = objectify.DataElement("test this") 165 self.assertEquals(value.nsmap, DEFAULT_NSMAP)
166
168 nsmap = {} 169 value = objectify.DataElement("test this", nsmap=nsmap) 170 self.assertEquals(list(value.nsmap.values()), [PYTYPE_NAMESPACE])
171
173 nsmap = {"mypy": PYTYPE_NAMESPACE, 174 "myxsi": XML_SCHEMA_INSTANCE_NS, 175 "myxsd": XML_SCHEMA_NS} 176 value = objectify.DataElement("test this", nsmap=nsmap) 177 self.assertEquals(value.nsmap, nsmap)
178
180 nsmap = {"my": "someNS", 181 "myother": "someOtherNS", 182 "myxsd": XML_SCHEMA_NS,} 183 value = objectify.DataElement("test", nsmap=nsmap) 184 self.assert_(PYTYPE_NAMESPACE in value.nsmap.values()) 185 for prefix, ns in nsmap.items(): 186 self.assert_(prefix in value.nsmap) 187 self.assertEquals(nsmap[prefix], value.nsmap[prefix])
188
190 root = objectify.Element("root") 191 root.value = objectify.DataElement("test this") 192 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)
193
195 root = objectify.Element("root") 196 nsmap = {} 197 root.value = objectify.DataElement("test this", nsmap=nsmap) 198 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)
199
201 root = objectify.Element("root") 202 nsmap = {"mypy": PYTYPE_NAMESPACE, 203 "myxsi": XML_SCHEMA_INSTANCE_NS, 204 "myxsd": XML_SCHEMA_NS} 205 root.value = objectify.DataElement("test this", nsmap=nsmap) 206 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)
207
209 root = objectify.Element("root") 210 nsmap = {"my": "someNS", 211 "myother": "someOtherNS", 212 "myxsd": XML_SCHEMA_NS} 213 root.value = objectify.DataElement("test", nsmap=nsmap) 214 expected = nsmap.copy() 215 del expected["myxsd"] 216 expected.update(DEFAULT_NSMAP) 217 self.assertEquals(root.value.nsmap, expected)
218
220 # keyword arguments override attrib entries 221 value = objectify.DataElement(23, _pytype="str", _xsi="foobar", 222 attrib={"gnu": "muh", "cat": "meeow", 223 "dog": "wuff"}, 224 bird="tchilp", dog="grrr") 225 self.assertEquals(value.get("gnu"), "muh") 226 self.assertEquals(value.get("cat"), "meeow") 227 self.assertEquals(value.get("dog"), "grrr") 228 self.assertEquals(value.get("bird"), "tchilp")
229
231 # Check that DataElement preserves all attributes ObjectifiedDataElement 232 # arguments 233 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 234 attrib={"gnu": "muh", "cat": "meeow", 235 "dog": "wuff"}, 236 bird="tchilp", dog="grrr") 237 value = objectify.DataElement(arg) 238 self.assert_(isinstance(value, objectify.StringElement)) 239 for attr in arg.attrib: 240 self.assertEquals(value.get(attr), arg.get(attr))
241
243 # Check that _pytype arg overrides original py:pytype of 244 # ObjectifiedDataElement 245 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 246 attrib={"gnu": "muh", "cat": "meeow", 247 "dog": "wuff"}, 248 bird="tchilp", dog="grrr") 249 value = objectify.DataElement(arg, _pytype="NoneType") 250 self.assert_(isinstance(value, objectify.NoneElement)) 251 self.assertEquals(value.get(XML_SCHEMA_NIL_ATTR), "true") 252 self.assertEquals(value.text, None) 253 self.assertEquals(value.pyval, None) 254 for attr in arg.attrib: 255 #if not attr == objectify.PYTYPE_ATTRIBUTE: 256 self.assertEquals(value.get(attr), arg.get(attr))
257
259 # Check that _pytype arg overrides original py:pytype of 260 # ObjectifiedDataElement 261 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 262 attrib={"gnu": "muh", "cat": "meeow", 263 "dog": "wuff"}, 264 bird="tchilp", dog="grrr") 265 value = objectify.DataElement(arg, _pytype="int") 266 self.assert_(isinstance(value, objectify.IntElement)) 267 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 268 for attr in arg.attrib: 269 if not attr == objectify.PYTYPE_ATTRIBUTE: 270 self.assertEquals(value.get(attr), arg.get(attr))
271
273 # Check that _xsi arg overrides original xsi:type of given 274 # ObjectifiedDataElement 275 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 276 attrib={"gnu": "muh", "cat": "meeow", 277 "dog": "wuff"}, 278 bird="tchilp", dog="grrr") 279 value = objectify.DataElement(arg, _xsi="xsd:int") 280 self.assert_(isinstance(value, objectify.IntElement)) 281 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 282 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 283 for attr in arg.attrib: 284 if not attr in [objectify.PYTYPE_ATTRIBUTE, 285 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 286 self.assertEquals(value.get(attr), arg.get(attr))
287
289 # Check that _pytype and _xsi args override original py:pytype and 290 # xsi:type attributes of given ObjectifiedDataElement 291 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 292 attrib={"gnu": "muh", "cat": "meeow", 293 "dog": "wuff"}, 294 bird="tchilp", dog="grrr") 295 value = objectify.DataElement(arg, _pytype="int", _xsi="xsd:int") 296 self.assert_(isinstance(value, objectify.IntElement)) 297 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 298 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 299 for attr in arg.attrib: 300 if not attr in [objectify.PYTYPE_ATTRIBUTE, 301 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 302 self.assertEquals(value.get(attr), arg.get(attr))
303
305 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 306 _pytype="int")
307
309 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 310 _xsi="xsd:int")
311
313 arg = objectify.DataElement(3.1415) 314 self.assertRaises(ValueError, objectify.DataElement, arg, 315 _pytype="int")
316
318 arg = objectify.DataElement(3.1415) 319 self.assertRaises(ValueError, objectify.DataElement, arg, 320 _xsi="xsd:int")
321
322 - def test_root(self):
323 root = self.Element("test") 324 self.assert_(isinstance(root, objectify.ObjectifiedElement))
325
326 - def test_str(self):
327 root = self.Element("test") 328 self.assertEquals('', str(root))
329
330 - def test_child(self):
331 root = self.XML(xml_str) 332 self.assertEquals("0", root.c1.c2.text)
333
334 - def test_countchildren(self):
335 root = self.XML(xml_str) 336 self.assertEquals(1, root.countchildren()) 337 self.assertEquals(5, root.c1.countchildren())
338
339 - def test_child_getattr(self):
340 root = self.XML(xml_str) 341 self.assertEquals("0", getattr(root.c1, "{objectified}c2").text) 342 self.assertEquals("3", getattr(root.c1, "{otherNS}c2").text)
343
344 - def test_child_nonexistant(self):
345 root = self.XML(xml_str) 346 self.assertRaises(AttributeError, getattr, root.c1, "NOT_THERE") 347 self.assertRaises(AttributeError, getattr, root.c1, "{unknownNS}c2")
348
349 - def test_setattr(self):
350 for val in [ 351 2, 2**32, 1.2, "Won't get fooled again", 352 _str("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1'), True, 353 False, None]: 354 root = self.Element('root') 355 attrname = 'val' 356 setattr(root, attrname, val) 357 result = getattr(root, attrname) 358 self.assertEquals(val, result) 359 self.assertEquals(type(val), type(result.pyval))
360
361 - def test_setattr_nonunicode(self):
362 root = self.Element('root') 363 attrname = 'val' 364 val = _bytes("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1') 365 self.assertRaises(ValueError, setattr, root, attrname, val) 366 self.assertRaises(AttributeError, getattr, root, attrname)
367
368 - def test_addattr(self):
369 root = self.XML(xml_str) 370 self.assertEquals(1, len(root.c1)) 371 root.addattr("c1", "test") 372 self.assertEquals(2, len(root.c1)) 373 self.assertEquals("test", root.c1[1].text)
374
375 - def test_addattr_element(self):
376 root = self.XML(xml_str) 377 self.assertEquals(1, len(root.c1)) 378 379 new_el = self.Element("test", myattr="5") 380 root.addattr("c1", new_el) 381 self.assertEquals(2, len(root.c1)) 382 self.assertEquals(None, root.c1[0].get("myattr")) 383 self.assertEquals("5", root.c1[1].get("myattr"))
384
385 - def test_addattr_list(self):
386 root = self.XML(xml_str) 387 self.assertEquals(1, len(root.c1)) 388 389 new_el = self.Element("test") 390 self.etree.SubElement(new_el, "a", myattr="A") 391 self.etree.SubElement(new_el, "a", myattr="B") 392 393 root.addattr("c1", list(new_el.a)) 394 self.assertEquals(3, len(root.c1)) 395 self.assertEquals(None, root.c1[0].get("myattr")) 396 self.assertEquals("A", root.c1[1].get("myattr")) 397 self.assertEquals("B", root.c1[2].get("myattr"))
398
399 - def test_child_addattr(self):
400 root = self.XML(xml_str) 401 self.assertEquals(3, len(root.c1.c2)) 402 root.c1.addattr("c2", 3) 403 self.assertEquals(4, len(root.c1.c2)) 404 self.assertEquals("3", root.c1.c2[3].text)
405
406 - def test_child_index(self):
407 root = self.XML(xml_str) 408 self.assertEquals("0", root.c1.c2[0].text) 409 self.assertEquals("1", root.c1.c2[1].text) 410 self.assertEquals("2", root.c1.c2[2].text) 411 self.assertRaises(IndexError, operator.getitem, root.c1.c2, 3)
412
413 - def test_child_index_neg(self):
414 root = self.XML(xml_str) 415 self.assertEquals("0", root.c1.c2[0].text) 416 self.assertEquals("0", root.c1.c2[-3].text) 417 self.assertEquals("1", root.c1.c2[-2].text) 418 self.assertEquals("2", root.c1.c2[-1].text) 419 self.assertRaises(IndexError, operator.getitem, root.c1.c2, -4)
420
421 - def test_child_len(self):
422 root = self.XML(xml_str) 423 self.assertEquals(1, len(root)) 424 self.assertEquals(1, len(root.c1)) 425 self.assertEquals(3, len(root.c1.c2))
426
427 - def test_child_iter(self):
428 root = self.XML(xml_str) 429 self.assertEquals([root], 430 list(iter(root))) 431 self.assertEquals([root.c1], 432 list(iter(root.c1))) 433 self.assertEquals([root.c1.c2[0], root.c1.c2[1], root.c1.c2[2]], 434 list(iter((root.c1.c2))))
435
436 - def test_class_lookup(self):
437 root = self.XML(xml_str) 438 self.assert_(isinstance(root.c1.c2, objectify.ObjectifiedElement)) 439 self.assertFalse(isinstance(getattr(root.c1, "{otherNS}c2"), 440 objectify.ObjectifiedElement))
441
442 - def test_dir(self):
443 root = self.XML(xml_str) 444 dir_c1 = dir(objectify.ObjectifiedElement) + ['c1'] 445 dir_c1.sort() 446 dir_c2 = dir(objectify.ObjectifiedElement) + ['c2'] 447 dir_c2.sort() 448 449 self.assertEquals(dir_c1, dir(root)) 450 self.assertEquals(dir_c2, dir(root.c1))
451
452 - def test_vars(self):
453 root = self.XML(xml_str) 454 self.assertEquals({'c1' : root.c1}, vars(root)) 455 self.assertEquals({'c2' : root.c1.c2}, vars(root.c1))
456
457 - def test_child_set_ro(self):
458 root = self.XML(xml_str) 459 self.assertRaises(TypeError, setattr, root.c1.c2, 'text', "test") 460 self.assertRaises(TypeError, setattr, root.c1.c2, 'pyval', "test")
461 462 # slicing 463
464 - def test_getslice_complete(self):
465 root = self.XML("<root><c>c1</c><c>c2</c></root>") 466 self.assertEquals(["c1", "c2"], 467 [ c.text for c in root.c[:] ])
468
469 - def test_getslice_partial(self):
470 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 471 test_list = ["c1", "c2", "c3", "c4"] 472 473 self.assertEquals(test_list, 474 [ c.text for c in root.c[:] ]) 475 self.assertEquals(test_list[1:2], 476 [ c.text for c in root.c[1:2] ]) 477 self.assertEquals(test_list[-3:-1], 478 [ c.text for c in root.c[-3:-1] ]) 479 self.assertEquals(test_list[-3:3], 480 [ c.text for c in root.c[-3:3] ]) 481 self.assertEquals(test_list[-3000:3], 482 [ c.text for c in root.c[-3000:3] ]) 483 self.assertEquals(test_list[-3:3000], 484 [ c.text for c in root.c[-3:3000] ])
485
486 - def test_getslice_partial_neg(self):
487 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 488 test_list = ["c1", "c2", "c3", "c4"] 489 490 self.assertEquals(test_list, 491 [ c.text for c in root.c[:] ]) 492 self.assertEquals(test_list[2:1:-1], 493 [ c.text for c in root.c[2:1:-1] ]) 494 self.assertEquals(test_list[-1:-3:-1], 495 [ c.text for c in root.c[-1:-3:-1] ]) 496 self.assertEquals(test_list[2:-3:-1], 497 [ c.text for c in root.c[2:-3:-1] ]) 498 self.assertEquals(test_list[2:-3000:-1], 499 [ c.text for c in root.c[2:-3000:-1] ])
500 501 # slice assignment 502
503 - def test_setslice_complete(self):
504 Element = self.Element 505 root = Element("root") 506 root.c = ["c1", "c2"] 507 508 c1 = root.c[0] 509 c2 = root.c[1] 510 511 self.assertEquals([c1,c2], list(root.c)) 512 self.assertEquals(["c1", "c2"], 513 [ c.text for c in root.c ])
514
515 - def test_setslice_elements(self):
516 Element = self.Element 517 root = Element("root") 518 root.c = ["c1", "c2"] 519 520 c1 = root.c[0] 521 c2 = root.c[1] 522 523 self.assertEquals([c1,c2], list(root.c)) 524 self.assertEquals(["c1", "c2"], 525 [ c.text for c in root.c ]) 526 527 root2 = Element("root2") 528 root2.el = [ "test", "test" ] 529 self.assertEquals(["test", "test"], 530 [ el.text for el in root2.el ]) 531 532 root.c = [ root2.el, root2.el ] 533 self.assertEquals(["test", "test"], 534 [ c.text for c in root.c ]) 535 self.assertEquals(["test", "test"], 536 [ el.text for el in root2.el ]) 537 538 root.c[:] = [ c1, c2, c2, c1 ] 539 self.assertEquals(["c1", "c2", "c2", "c1"], 540 [ c.text for c in root.c ])
541
542 - def test_setslice_partial(self):
543 Element = self.Element 544 root = Element("root") 545 l = ["c1", "c2", "c3", "c4"] 546 root.c = l 547 548 self.assertEquals(["c1", "c2", "c3", "c4"], 549 [ c.text for c in root.c ]) 550 self.assertEquals(l, 551 [ c.text for c in root.c ]) 552 553 new_slice = ["cA", "cB"] 554 l[1:2] = new_slice 555 root.c[1:2] = new_slice 556 557 self.assertEquals(["c1", "cA", "cB", "c3", "c4"], l) 558 self.assertEquals(["c1", "cA", "cB", "c3", "c4"], 559 [ c.text for c in root.c ]) 560 self.assertEquals(l, 561 [ c.text for c in root.c ])
562
563 - def test_setslice_insert(self):
564 Element = self.Element 565 root = Element("root") 566 l = ["c1", "c2", "c3", "c4"] 567 root.c = l 568 569 self.assertEquals(["c1", "c2", "c3", "c4"], 570 [ c.text for c in root.c ]) 571 self.assertEquals(l, 572 [ c.text for c in root.c ]) 573 574 new_slice = ["cA", "cB"] 575 l[1:1] = new_slice 576 root.c[1:1] = new_slice 577 578 self.assertEquals(["c1", "cA", "cB", "c2", "c3", "c4"], l) 579 self.assertEquals(["c1", "cA", "cB", "c2", "c3", "c4"], 580 [ c.text for c in root.c ]) 581 self.assertEquals(l, 582 [ c.text for c in root.c ])
583
584 - def test_setslice_insert_neg(self):
585 Element = self.Element 586 root = Element("root") 587 l = ["c1", "c2", "c3", "c4"] 588 root.c = l 589 590 self.assertEquals(["c1", "c2", "c3", "c4"], 591 [ c.text for c in root.c ]) 592 self.assertEquals(l, 593 [ c.text for c in root.c ]) 594 595 new_slice = ["cA", "cB"] 596 l[-2:-2] = new_slice 597 root.c[-2:-2] = new_slice 598 599 self.assertEquals(["c1", "c2", "cA", "cB", "c3", "c4"], l) 600 self.assertEquals(["c1", "c2", "cA", "cB", "c3", "c4"], 601 [ c.text for c in root.c ]) 602 self.assertEquals(l, 603 [ c.text for c in root.c ])
604
605 - def test_setslice_empty(self):
606 Element = self.Element 607 root = Element("root") 608 609 root.c = [] 610 self.assertRaises( 611 AttributeError, getattr, root, 'c')
612
614 Element = self.Element 615 root = Element("root") 616 l = ["c1", "c2", "c3", "c4"] 617 root.c = l 618 619 self.assertEquals(["c1", "c2", "c3", "c4"], 620 [ c.text for c in root.c ]) 621 self.assertEquals(l, 622 [ c.text for c in root.c ]) 623 624 new_slice = ["cA", "cB", "cC"] 625 self.assertRaises( 626 ValueError, operator.setitem, 627 l, slice(1,2,-1), new_slice) 628 self.assertRaises( 629 ValueError, operator.setitem, 630 root.c, slice(1,2,-1), new_slice)
631
632 - def test_setslice_partial_neg(self):
633 Element = self.Element 634 root = Element("root") 635 l = ["c1", "c2", "c3", "c4"] 636 root.c = l 637 638 self.assertEquals(["c1", "c2", "c3", "c4"], 639 [ c.text for c in root.c ]) 640 self.assertEquals(l, 641 [ c.text for c in root.c ]) 642 643 new_slice = ["cA", "cB"] 644 l[-1:1:-1] = new_slice 645 root.c[-1:1:-1] = new_slice 646 647 self.assertEquals(["c1", "c2", "cB", "cA"], l) 648 self.assertEquals(["c1", "c2", "cB", "cA"], 649 [ c.text for c in root.c ]) 650 self.assertEquals(l, 651 [ c.text for c in root.c ])
652
654 Element = self.Element 655 root = Element("root") 656 l = ["c1", "c2", "c3", "c4"] 657 root.c = l 658 659 self.assertEquals(["c1", "c2", "c3", "c4"], 660 [ c.text for c in root.c ]) 661 self.assertEquals(l, 662 [ c.text for c in root.c ]) 663 664 new_slice = ["cA", "cB"] 665 l[-1:-4:-2] = new_slice 666 root.c[-1:-4:-2] = new_slice 667 668 self.assertEquals(["c1", "cB", "c3", "cA"], l) 669 self.assertEquals(["c1", "cB", "c3", "cA"], 670 [ c.text for c in root.c ]) 671 self.assertEquals(l, 672 [ c.text for c in root.c ])
673 674 # other stuff 675
676 - def test_set_string(self):
677 # make sure strings are not handled as sequences 678 Element = self.Element 679 root = Element("root") 680 root.c = "TEST" 681 self.assertEquals(["TEST"], 682 [ c.text for c in root.c ])
683
684 - def test_setitem_string(self):
685 # make sure strings are set as children 686 Element = self.Element 687 root = Element("root") 688 root["c"] = "TEST" 689 self.assertEquals(["TEST"], 690 [ c.text for c in root.c ])
691
693 # make sure 'text' etc. are set as children 694 Element = self.Element 695 root = Element("root") 696 697 root["text"] = "TEST" 698 self.assertEquals(["TEST"], 699 [ c.text for c in root["text"] ]) 700 701 root["tail"] = "TEST" 702 self.assertEquals(["TEST"], 703 [ c.text for c in root["tail"] ]) 704 705 root["pyval"] = "TEST" 706 self.assertEquals(["TEST"], 707 [ c.text for c in root["pyval"] ]) 708 709 root["tag"] = "TEST" 710 self.assertEquals(["TEST"], 711 [ c.text for c in root["tag"] ])
712
713 - def test_findall(self):
714 XML = self.XML 715 root = XML('<a><b><c/></b><b/><c><b/></c></a>') 716 self.assertEquals(1, len(root.findall("c"))) 717 self.assertEquals(2, len(root.findall(".//c"))) 718 self.assertEquals(3, len(root.findall(".//b"))) 719 self.assert_(root.findall(".//b")[1] is root.getchildren()[1])
720
721 - def test_findall_ns(self):
722 XML = self.XML 723 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>') 724 self.assertEquals(2, len(root.findall(".//{X}b"))) 725 self.assertEquals(3, len(root.findall(".//b"))) 726 self.assertEquals(2, len(root.findall("b")))
727
728 - def test_build_tree(self):
729 root = self.Element('root') 730 root.a = 5 731 root.b = 6 732 self.assert_(isinstance(root, objectify.ObjectifiedElement)) 733 self.assert_(isinstance(root.a, objectify.IntElement)) 734 self.assert_(isinstance(root.b, objectify.IntElement))
735
736 - def test_type_NoneType(self):
737 Element = self.Element 738 SubElement = self.etree.SubElement 739 740 nil_attr = XML_SCHEMA_NIL_ATTR 741 root = Element("{objectified}root") 742 SubElement(root, "{objectified}none") 743 SubElement(root, "{objectified}none", {nil_attr : "true"}) 744 self.assertFalse(isinstance(root.none, objectify.NoneElement)) 745 self.assertFalse(isinstance(root.none[0], objectify.NoneElement)) 746 self.assert_(isinstance(root.none[1], objectify.NoneElement)) 747 self.assertEquals(hash(root.none[1]), hash(None)) 748 self.assertEquals(root.none[1], None) 749 self.assertFalse(root.none[1])
750
751 - def test_data_element_NoneType(self):
752 value = objectify.DataElement(None) 753 self.assert_(isinstance(value, objectify.NoneElement)) 754 self.assertEquals(value, None) 755 self.assertEquals(value.get(XML_SCHEMA_NIL_ATTR), "true")
756
757 - def test_type_bool(self):
758 Element = self.Element 759 SubElement = self.etree.SubElement 760 root = Element("{objectified}root") 761 root.bool = True 762 self.assertEquals(root.bool, True) 763 self.assertEquals(root.bool + root.bool, True + True) 764 self.assertEquals(True + root.bool, True + root.bool) 765 self.assertEquals(root.bool * root.bool, True * True) 766 self.assertEquals(int(root.bool), int(True)) 767 self.assertEquals(hash(root.bool), hash(True)) 768 self.assertEquals(complex(root.bool), complex(True)) 769 self.assert_(isinstance(root.bool, objectify.BoolElement)) 770 771 root.bool = False 772 self.assertEquals(root.bool, False) 773 self.assertEquals(root.bool + root.bool, False + False) 774 self.assertEquals(False + root.bool, False + root.bool) 775 self.assertEquals(root.bool * root.bool, False * False) 776 self.assertEquals(int(root.bool), int(False)) 777 self.assertEquals(hash(root.bool), hash(False)) 778 self.assertEquals(complex(root.bool), complex(False)) 779 self.assert_(isinstance(root.bool, objectify.BoolElement))
780
781 - def test_data_element_bool(self):
782 value = objectify.DataElement(True) 783 self.assert_(isinstance(value, objectify.BoolElement)) 784 self.assertEquals(value, True) 785 786 value = objectify.DataElement(False) 787 self.assert_(isinstance(value, objectify.BoolElement)) 788 self.assertEquals(value, False)
789
790 - def test_type_str(self):
791 Element = self.Element 792 SubElement = self.etree.SubElement 793 root = Element("{objectified}root") 794 root.s = "test" 795 self.assert_(isinstance(root.s, objectify.StringElement))
796
797 - def test_type_str_intliteral(self):
798 Element = self.Element 799 SubElement = self.etree.SubElement 800 root = Element("{objectified}root") 801 root.s = "3" 802 self.assert_(isinstance(root.s, objectify.StringElement))
803
804 - def test_type_str_floatliteral(self):
805 Element = self.Element 806 SubElement = self.etree.SubElement 807 root = Element("{objectified}root") 808 root.s = "3.72" 809 self.assert_(isinstance(root.s, objectify.StringElement))
810
811 - def test_type_str_mul(self):
812 Element = self.Element 813 SubElement = self.etree.SubElement 814 root = Element("{objectified}root") 815 root.s = "test" 816 817 self.assertEquals("test" * 5, root.s * 5) 818 self.assertEquals(5 * "test", 5 * root.s) 819 820 self.assertRaises(TypeError, operator.mul, root.s, "honk") 821 self.assertRaises(TypeError, operator.mul, "honk", root.s)
822
823 - def test_type_str_add(self):
824 Element = self.Element 825 SubElement = self.etree.SubElement 826 root = Element("{objectified}root") 827 root.s = "test" 828 829 s = "toast" 830 self.assertEquals("test" + s, root.s + s) 831 self.assertEquals(s + "test", s + root.s)
832
833 - def test_type_str_mod(self):
834 s = "%d %f %s %r" 835 el = objectify.DataElement(s) 836 values = (1, 7.0, "abcd", None) 837 self.assertEquals(s % values, el % values) 838 839 s = "%d" 840 el = objectify.DataElement(s) 841 val = 5 842 self.assertEquals(s % val, el % val) 843 844 s = "%d %s" 845 el = objectify.DataElement(s) 846 val = 5 847 self.assertRaises(TypeError, el.__mod__, val) 848 849 s = "" 850 el = objectify.DataElement(s) 851 val = 5 852 self.assertRaises(TypeError, el.__mod__, val)
853
854 - def test_type_str_hash(self):
855 v = "1" 856 el = objectify.DataElement(v) 857 self.assertEquals(hash(el), hash("1"))
858
859 - def test_type_str_as_int(self):
860 v = "1" 861 el = objectify.DataElement(v) 862 self.assertEquals(int(el), 1)
863
864 - def test_type_str_as_float(self):
865 v = "1" 866 el = objectify.DataElement(v) 867 self.assertEquals(float(el), 1)
868
869 - def test_type_str_as_complex(self):
870 v = "1" 871 el = objectify.DataElement(v) 872 self.assertEquals(complex(el), 1)
873
875 s = "%d %f %s %r" 876 el = objectify.DataElement(s) 877 values = (objectify.DataElement(1), 878 objectify.DataElement(7.0), 879 objectify.DataElement("abcd"), 880 objectify.DataElement(None)) 881 self.assertEquals(s % values, el % values)
882
883 - def test_data_element_str(self):
884 value = objectify.DataElement("test") 885 self.assert_(isinstance(value, objectify.StringElement)) 886 self.assertEquals(value, "test")
887
889 value = objectify.DataElement("3") 890 self.assert_(isinstance(value, objectify.StringElement)) 891 self.assertEquals(value, "3")
892
894 value = objectify.DataElement("3.20") 895 self.assert_(isinstance(value, objectify.StringElement)) 896 self.assertEquals(value, "3.20")
897
898 - def test_type_ustr(self):
899 Element = self.Element 900 SubElement = self.etree.SubElement 901 root = Element("{objectified}root") 902 root.s = _str("test") 903 self.assert_(isinstance(root.s, objectify.StringElement))
904
905 - def test_type_ustr_intliteral(self):
906 Element = self.Element 907 SubElement = self.etree.SubElement 908 root = Element("{objectified}root") 909 root.s = _str("3") 910 self.assert_(isinstance(root.s, objectify.StringElement))
911
913 Element = self.Element 914 SubElement = self.etree.SubElement 915 root = Element("{objectified}root") 916 root.s = _str("3.72") 917 self.assert_(isinstance(root.s, objectify.StringElement))
918
919 - def test_type_ustr_mul(self):
920 Element = self.Element 921 SubElement = self.etree.SubElement 922 root = Element("{objectified}root") 923 root.s = _str("test") 924 925 self.assertEquals(_str("test") * 5, root.s * 5) 926 self.assertEquals(5 * _str("test"), 5 * root.s) 927 928 self.assertRaises(TypeError, operator.mul, root.s, _str("honk")) 929 self.assertRaises(TypeError, operator.mul, _str("honk"), root.s)
930
931 - def test_type_ustr_add(self):
932 Element = self.Element 933 SubElement = self.etree.SubElement 934 root = Element("{objectified}root") 935 root.s = _str("test") 936 937 s = _str("toast") 938 self.assertEquals(_str("test") + s, root.s + s) 939 self.assertEquals(s + _str("test"), s + root.s)
940
941 - def test_data_element_ustr(self):
942 value = objectify.DataElement(_str("test")) 943 self.assert_(isinstance(value, objectify.StringElement)) 944 self.assertEquals(value, _str("test"))
945
947 value = objectify.DataElement("3") 948 self.assert_(isinstance(value, objectify.StringElement)) 949 self.assertEquals(value, _str("3"))
950
952 value = objectify.DataElement(_str("3.20")) 953 self.assert_(isinstance(value, objectify.StringElement)) 954 self.assertEquals(value, _str("3.20"))
955
956 - def test_type_int(self):
957 Element = self.Element 958 SubElement = self.etree.SubElement 959 root = Element("{objectified}root") 960 root.none = 5 961 self.assert_(isinstance(root.none, objectify.IntElement))
962
963 - def test_data_element_int(self):
964 value = objectify.DataElement(5) 965 self.assert_(isinstance(value, objectify.IntElement)) 966 self.assertEquals(value, 5)
967
968 - def test_data_element_int_hash(self):
969 value = objectify.DataElement(123) 970 self.assertEquals(hash(value), hash(123))
971
972 - def test_type_float(self):
973 Element = self.Element 974 SubElement = self.etree.SubElement 975 root = Element("{objectified}root") 976 root.none = 5.5 977 self.assert_(isinstance(root.none, objectify.FloatElement))
978
979 - def test_data_element_float(self):
980 value = objectify.DataElement(5.5) 981 self.assert_(isinstance(value, objectify.FloatElement)) 982 self.assertEquals(value, 5.5)
983
985 value = objectify.DataElement(5.5) 986 self.assertEquals(hash(value), hash(5.5))
987
988 - def test_data_element_xsitypes(self):
989 for xsi, objclass in xsitype2objclass.items(): 990 # 1 is a valid value for all ObjectifiedDataElement classes 991 pyval = 1 992 value = objectify.DataElement(pyval, _xsi=xsi) 993 self.assert_(isinstance(value, objclass), 994 "DataElement(%s, _xsi='%s') returns %s, expected %s" 995 % (pyval, xsi, type(value), objclass))
996
998 for xsi, objclass in xsitype2objclass.items(): 999 # 1 is a valid value for all ObjectifiedDataElement classes 1000 pyval = 1 1001 value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi) 1002 self.assert_(isinstance(value, objclass), 1003 "DataElement(%s, _xsi='%s') returns %s, expected %s" 1004 % (pyval, xsi, type(value), objclass))
1005
1007 for xsi, objclass in xsitype2objclass.items(): 1008 # 1 is a valid value for all ObjectifiedDataElement classes 1009 self.assertRaises(ValueError, objectify.DataElement, 1, 1010 _xsi="foo:%s" % xsi)
1011
1012 - def test_data_element_pytypes(self):
1013 for pytype, objclass in pytype2objclass.items(): 1014 # 1 is a valid value for all ObjectifiedDataElement classes 1015 pyval = 1 1016 value = objectify.DataElement(pyval, _pytype=pytype) 1017 self.assert_(isinstance(value, objclass), 1018 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1019 % (pyval, pytype, type(value), objclass))
1020
1022 pyval = 1 1023 pytype = "NoneType" 1024 objclass = objectify.NoneElement 1025 value = objectify.DataElement(pyval, _pytype=pytype) 1026 self.assert_(isinstance(value, objclass), 1027 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1028 % (pyval, pytype, type(value), objclass)) 1029 self.assertEquals(value.text, None) 1030 self.assertEquals(value.pyval, None)
1031
1033 # pre-2.0 lxml called NoneElement "none" 1034 pyval = 1 1035 pytype = "none" 1036 objclass = objectify.NoneElement 1037 value = objectify.DataElement(pyval, _pytype=pytype) 1038 self.assert_(isinstance(value, objclass), 1039 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1040 % (pyval, pytype, type(value), objclass)) 1041 self.assertEquals(value.text, None) 1042 self.assertEquals(value.pyval, None)
1043
1044 - def test_type_unregistered(self):
1045 Element = self.Element 1046 SubElement = self.etree.SubElement 1047 class MyFloat(float): 1048 pass
1049 root = Element("{objectified}root") 1050 root.myfloat = MyFloat(5.5) 1051 self.assert_(isinstance(root.myfloat, objectify.FloatElement)) 1052 self.assertEquals(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None)
1053
1054 - def test_data_element_unregistered(self):
1055 class MyFloat(float): 1056 pass
1057 value = objectify.DataElement(MyFloat(5.5)) 1058 self.assert_(isinstance(value, objectify.FloatElement)) 1059 self.assertEquals(value, 5.5) 1060 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), None) 1061
1062 - def test_schema_types(self):
1063 XML = self.XML 1064 root = XML('''\ 1065 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1066 <b xsi:type="boolean">true</b> 1067 <b xsi:type="boolean">false</b> 1068 <b xsi:type="boolean">1</b> 1069 <b xsi:type="boolean">0</b> 1070 1071 <f xsi:type="float">5</f> 1072 <f xsi:type="double">5</f> 1073 1074 <s xsi:type="string">5</s> 1075 <s xsi:type="normalizedString">5</s> 1076 <s xsi:type="token">5</s> 1077 <s xsi:type="language">5</s> 1078 <s xsi:type="Name">5</s> 1079 <s xsi:type="NCName">5</s> 1080 <s xsi:type="ID">5</s> 1081 <s xsi:type="IDREF">5</s> 1082 <s xsi:type="ENTITY">5</s> 1083 <s xsi:type="NMTOKEN">5</s> 1084 1085 <l xsi:type="integer">5</l> 1086 <l xsi:type="nonPositiveInteger">5</l> 1087 <l xsi:type="negativeInteger">5</l> 1088 <l xsi:type="long">5</l> 1089 <l xsi:type="nonNegativeInteger">5</l> 1090 <l xsi:type="unsignedLong">5</l> 1091 <l xsi:type="unsignedInt">5</l> 1092 <l xsi:type="positiveInteger">5</l> 1093 1094 <i xsi:type="int">5</i> 1095 <i xsi:type="short">5</i> 1096 <i xsi:type="byte">5</i> 1097 <i xsi:type="unsignedShort">5</i> 1098 <i xsi:type="unsignedByte">5</i> 1099 1100 <n xsi:nil="true"/> 1101 </root> 1102 ''') 1103 1104 for b in root.b: 1105 self.assert_(isinstance(b, objectify.BoolElement)) 1106 self.assertEquals(True, root.b[0]) 1107 self.assertEquals(False, root.b[1]) 1108 self.assertEquals(True, root.b[2]) 1109 self.assertEquals(False, root.b[3]) 1110 1111 for f in root.f: 1112 self.assert_(isinstance(f, objectify.FloatElement)) 1113 self.assertEquals(5, f) 1114 1115 for s in root.s: 1116 self.assert_(isinstance(s, objectify.StringElement)) 1117 self.assertEquals("5", s) 1118 1119 for i in root.i: 1120 self.assert_(isinstance(i, objectify.IntElement)) 1121 self.assertEquals(5, i) 1122 1123 for l in root.l: 1124 self.assert_(isinstance(l, objectify.IntElement)) 1125 self.assertEquals(5, i) 1126 1127 self.assert_(isinstance(root.n, objectify.NoneElement)) 1128 self.assertEquals(None, root.n)
1129
1130 - def test_schema_types_prefixed(self):
1131 XML = self.XML 1132 root = XML('''\ 1133 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1134 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1135 <b xsi:type="xsd:boolean">true</b> 1136 <b xsi:type="xsd:boolean">false</b> 1137 <b xsi:type="xsd:boolean">1</b> 1138 <b xsi:type="xsd:boolean">0</b> 1139 1140 <f xsi:type="xsd:float">5</f> 1141 <f xsi:type="xsd:double">5</f> 1142 1143 <s xsi:type="xsd:string">5</s> 1144 <s xsi:type="xsd:normalizedString">5</s> 1145 <s xsi:type="xsd:token">5</s> 1146 <s xsi:type="xsd:language">5</s> 1147 <s xsi:type="xsd:Name">5</s> 1148 <s xsi:type="xsd:NCName">5</s> 1149 <s xsi:type="xsd:ID">5</s> 1150 <s xsi:type="xsd:IDREF">5</s> 1151 <s xsi:type="xsd:ENTITY">5</s> 1152 <s xsi:type="xsd:NMTOKEN">5</s> 1153 1154 <l xsi:type="xsd:integer">5</l> 1155 <l xsi:type="xsd:nonPositiveInteger">5</l> 1156 <l xsi:type="xsd:negativeInteger">5</l> 1157 <l xsi:type="xsd:long">5</l> 1158 <l xsi:type="xsd:nonNegativeInteger">5</l> 1159 <l xsi:type="xsd:unsignedLong">5</l> 1160 <l xsi:type="xsd:unsignedInt">5</l> 1161 <l xsi:type="xsd:positiveInteger">5</l> 1162 1163 <i xsi:type="xsd:int">5</i> 1164 <i xsi:type="xsd:short">5</i> 1165 <i xsi:type="xsd:byte">5</i> 1166 <i xsi:type="xsd:unsignedShort">5</i> 1167 <i xsi:type="xsd:unsignedByte">5</i> 1168 1169 <n xsi:nil="true"/> 1170 </root> 1171 ''') 1172 1173 for b in root.b: 1174 self.assert_(isinstance(b, objectify.BoolElement)) 1175 self.assertEquals(True, root.b[0]) 1176 self.assertEquals(False, root.b[1]) 1177 self.assertEquals(True, root.b[2]) 1178 self.assertEquals(False, root.b[3]) 1179 1180 for f in root.f: 1181 self.assert_(isinstance(f, objectify.FloatElement)) 1182 self.assertEquals(5, f) 1183 1184 for s in root.s: 1185 self.assert_(isinstance(s, objectify.StringElement)) 1186 self.assertEquals("5", s) 1187 1188 for i in root.i: 1189 self.assert_(isinstance(i, objectify.IntElement)) 1190 self.assertEquals(5, i) 1191 1192 for l in root.l: 1193 self.assert_(isinstance(l, objectify.IntElement)) 1194 self.assertEquals(5, l) 1195 1196 self.assert_(isinstance(root.n, objectify.NoneElement)) 1197 self.assertEquals(None, root.n)
1198
1199 - def test_type_str_sequence(self):
1200 XML = self.XML 1201 root = XML(_bytes('<root><b>why</b><b>try</b></root>')) 1202 strs = [ str(s) for s in root.b ] 1203 self.assertEquals(["why", "try"], 1204 strs)
1205
1206 - def test_type_str_cmp(self):
1207 XML = self.XML 1208 root = XML(_bytes('<root><b>test</b><b>taste</b><b></b><b/></root>')) 1209 self.assertFalse(root.b[0] < root.b[1]) 1210 self.assertFalse(root.b[0] <= root.b[1]) 1211 self.assertFalse(root.b[0] == root.b[1]) 1212 1213 self.assert_(root.b[0] != root.b[1]) 1214 self.assert_(root.b[0] >= root.b[1]) 1215 self.assert_(root.b[0] > root.b[1]) 1216 1217 self.assertEquals(root.b[0], "test") 1218 self.assertEquals("test", root.b[0]) 1219 1220 self.assertEquals("", root.b[2]) 1221 self.assertEquals(root.b[2], "") 1222 self.assertEquals("", root.b[3]) 1223 self.assertEquals(root.b[3], "") 1224 self.assertEquals(root.b[2], root.b[3]) 1225 1226 root.b = "test" 1227 self.assert_(root.b) 1228 root.b = "" 1229 self.assertFalse(root.b) 1230 self.assertEquals(root.b, "") 1231 self.assertEquals("", root.b)
1232
1233 - def test_type_int_cmp(self):
1234 XML = self.XML 1235 root = XML(_bytes('<root><b>5</b><b>6</b></root>')) 1236 self.assert_(root.b[0] < root.b[1]) 1237 self.assert_(root.b[0] <= root.b[1]) 1238 self.assert_(root.b[0] != root.b[1]) 1239 1240 self.assertFalse(root.b[0] == root.b[1]) 1241 self.assertFalse(root.b[0] >= root.b[1]) 1242 self.assertFalse(root.b[0] > root.b[1]) 1243 1244 self.assertEquals(root.b[0], 5) 1245 self.assertEquals(5, root.b[0]) 1246 self.assertNotEquals(root.b[0], "5") 1247 1248 root.b = 5 1249 self.assert_(root.b) 1250 root.b = 0 1251 self.assertFalse(root.b)
1252 1253 # float + long share the NumberElement implementation with int 1254
1255 - def test_type_bool_cmp(self):
1256 XML = self.XML 1257 root = XML(_bytes('<root><b>false</b><b>true</b></root>')) 1258 self.assert_(root.b[0] < root.b[1]) 1259 self.assert_(root.b[0] <= root.b[1]) 1260 self.assert_(root.b[0] != root.b[1]) 1261 1262 self.assertFalse(root.b[0] == root.b[1]) 1263 self.assertFalse(root.b[0] >= root.b[1]) 1264 self.assertFalse(root.b[0] > root.b[1]) 1265 1266 self.assertFalse(root.b[0]) 1267 self.assert_(root.b[1]) 1268 1269 self.assertEquals(root.b[0], False) 1270 self.assertEquals(False, root.b[0]) 1271 self.assert_(root.b[0] < 5) 1272 self.assert_(5 > root.b[0]) 1273 1274 root.b = True 1275 self.assert_(root.b) 1276 root.b = False 1277 self.assertFalse(root.b)
1278
1279 - def test_type_none_cmp(self):
1280 XML = self.XML 1281 root = XML(_bytes(""" 1282 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1283 <b xsi:nil="true"></b><b xsi:nil="true"/> 1284 </root>""")) 1285 self.assert_(root.b[0] == root.b[1]) 1286 self.assertFalse(root.b[0]) 1287 self.assertEquals(root.b[0], None) 1288 self.assertEquals(None, root.b[0])
1289 1290 # doesn't work in Py3: 1291 1292 #for comparison in ["abc", 5, 7.3, True, [], ()]: 1293 # none = root.b[1] 1294 # self.assert_(none < comparison, "%s (%s) should be < %s" % 1295 # (none, type(none), comparison) ) 1296 # self.assert_(comparison > none, "%s should be > %s (%s)" % 1297 # (comparison, none, type(none)) ) 1298
1299 - def test_dataelement_xsi(self):
1300 el = objectify.DataElement(1, _xsi="string") 1301 self.assertEquals( 1302 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1303 'xsd:string')
1304
1305 - def test_dataelement_xsi_nsmap(self):
1306 el = objectify.DataElement(1, _xsi="string", 1307 nsmap={'schema': XML_SCHEMA_NS}) 1308 self.assertEquals( 1309 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1310 'schema:string')
1311
1312 - def test_dataelement_xsi_prefix_error(self):
1313 self.assertRaises(ValueError, objectify.DataElement, 1, 1314 _xsi="foo:string")
1315
1316 - def test_pytype_annotation(self):
1317 XML = self.XML 1318 root = XML(_bytes('''\ 1319 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1320 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1321 <b>5</b> 1322 <b>test</b> 1323 <c>1.1</c> 1324 <c>\uF8D2</c> 1325 <x>true</x> 1326 <n xsi:nil="true" /> 1327 <n></n> 1328 <b xsi:type="double">5</b> 1329 <b xsi:type="float">5</b> 1330 <s xsi:type="string">23</s> 1331 <s py:pytype="str">42</s> 1332 <f py:pytype="float">300</f> 1333 <l py:pytype="long">2</l> 1334 <t py:pytype="TREE"></t> 1335 </a> 1336 ''')) 1337 objectify.annotate(root) 1338 1339 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1340 for c in root.iterchildren() ] 1341 self.assertEquals("int", child_types[ 0]) 1342 self.assertEquals("str", child_types[ 1]) 1343 self.assertEquals("float", child_types[ 2]) 1344 self.assertEquals("str", child_types[ 3]) 1345 self.assertEquals("bool", child_types[ 4]) 1346 self.assertEquals("NoneType", child_types[ 5]) 1347 self.assertEquals(None, child_types[ 6]) 1348 self.assertEquals("float", child_types[ 7]) 1349 self.assertEquals("float", child_types[ 8]) 1350 self.assertEquals("str", child_types[ 9]) 1351 self.assertEquals("int", child_types[10]) 1352 self.assertEquals("int", child_types[11]) 1353 self.assertEquals("int", child_types[12]) 1354 self.assertEquals(None, child_types[13]) 1355 1356 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1357
1358 - def test_pytype_annotation_empty(self):
1359 XML = self.XML 1360 root = XML(_bytes('''\ 1361 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1362 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1363 <n></n> 1364 </a> 1365 ''')) 1366 objectify.annotate(root) 1367 1368 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1369 for c in root.iterchildren() ] 1370 self.assertEquals(None, child_types[0]) 1371 1372 objectify.annotate(root, empty_pytype="str") 1373 1374 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1375 for c in root.iterchildren() ] 1376 self.assertEquals("str", child_types[0])
1377
1378 - def test_pytype_annotation_use_old(self):
1379 XML = self.XML 1380 root = XML(_bytes('''\ 1381 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1382 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1383 <b>5</b> 1384 <b>test</b> 1385 <c>1.1</c> 1386 <c>\uF8D2</c> 1387 <x>true</x> 1388 <n xsi:nil="true" /> 1389 <n></n> 1390 <b xsi:type="double">5</b> 1391 <b xsi:type="float">5</b> 1392 <s xsi:type="string">23</s> 1393 <s py:pytype="str">42</s> 1394 <f py:pytype="float">300</f> 1395 <l py:pytype="long">2</l> 1396 <t py:pytype="TREE"></t> 1397 </a> 1398 ''')) 1399 objectify.annotate(root, ignore_old=False) 1400 1401 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1402 for c in root.iterchildren() ] 1403 self.assertEquals("int", child_types[ 0]) 1404 self.assertEquals("str", child_types[ 1]) 1405 self.assertEquals("float", child_types[ 2]) 1406 self.assertEquals("str", child_types[ 3]) 1407 self.assertEquals("bool", child_types[ 4]) 1408 self.assertEquals("NoneType", child_types[ 5]) 1409 self.assertEquals(None, child_types[ 6]) 1410 self.assertEquals("float", child_types[ 7]) 1411 self.assertEquals("float", child_types[ 8]) 1412 self.assertEquals("str", child_types[ 9]) 1413 self.assertEquals("str", child_types[10]) 1414 self.assertEquals("float", child_types[11]) 1415 self.assertEquals("int", child_types[12]) 1416 self.assertEquals(TREE_PYTYPE, child_types[13]) 1417 1418 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1419
1420 - def test_pytype_xsitype_annotation(self):
1421 XML = self.XML 1422 root = XML(_bytes('''\ 1423 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1424 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1425 <b>5</b> 1426 <b>test</b> 1427 <c>1.1</c> 1428 <c>\uF8D2</c> 1429 <x>true</x> 1430 <n xsi:nil="true" /> 1431 <n></n> 1432 <b xsi:type="double">5</b> 1433 <b xsi:type="float">5</b> 1434 <s xsi:type="string">23</s> 1435 <s py:pytype="str">42</s> 1436 <f py:pytype="float">300</f> 1437 <l py:pytype="long">2</l> 1438 <t py:pytype="TREE"></t> 1439 </a> 1440 ''')) 1441 objectify.annotate(root, ignore_old=False, ignore_xsi=False, 1442 annotate_xsi=1, annotate_pytype=1) 1443 1444 # check py annotations 1445 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1446 for c in root.iterchildren() ] 1447 self.assertEquals("int", child_types[ 0]) 1448 self.assertEquals("str", child_types[ 1]) 1449 self.assertEquals("float", child_types[ 2]) 1450 self.assertEquals("str", child_types[ 3]) 1451 self.assertEquals("bool", child_types[ 4]) 1452 self.assertEquals("NoneType", child_types[ 5]) 1453 self.assertEquals(None, child_types[ 6]) 1454 self.assertEquals("float", child_types[ 7]) 1455 self.assertEquals("float", child_types[ 8]) 1456 self.assertEquals("str", child_types[ 9]) 1457 self.assertEquals("str", child_types[10]) 1458 self.assertEquals("float", child_types[11]) 1459 self.assertEquals("int", child_types[12]) 1460 self.assertEquals(TREE_PYTYPE, child_types[13]) 1461 1462 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1463 1464 child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1465 for c in root.iterchildren() ] 1466 1467 # check xsi annotations 1468 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1469 for c in root.iterchildren() ] 1470 self.assertEquals("xsd:integer", child_types[ 0]) 1471 self.assertEquals("xsd:string", child_types[ 1]) 1472 self.assertEquals("xsd:double", child_types[ 2]) 1473 self.assertEquals("xsd:string", child_types[ 3]) 1474 self.assertEquals("xsd:boolean", child_types[ 4]) 1475 self.assertEquals(None, child_types[ 5]) 1476 self.assertEquals(None, child_types[ 6]) 1477 self.assertEquals("xsd:double", child_types[ 7]) 1478 self.assertEquals("xsd:float", child_types[ 8]) 1479 self.assertEquals("xsd:string", child_types[ 9]) 1480 self.assertEquals("xsd:string", child_types[10]) 1481 self.assertEquals("xsd:double", child_types[11]) 1482 self.assertEquals("xsd:integer", child_types[12]) 1483 self.assertEquals(None, child_types[13]) 1484 1485 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1486
1487 - def test_xsiannotate_use_old(self):
1488 XML = self.XML 1489 root = XML(_bytes('''\ 1490 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1491 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1492 <b>5</b> 1493 <b>test</b> 1494 <c>1.1</c> 1495 <c>\uF8D2</c> 1496 <x>true</x> 1497 <n xsi:nil="true" /> 1498 <n></n> 1499 <b xsi:type="double">5</b> 1500 <b xsi:type="float">5</b> 1501 <s xsi:type="string">23</s> 1502 <s py:pytype="str">42</s> 1503 <f py:pytype="float">300</f> 1504 <l py:pytype="long">2</l> 1505 <t py:pytype="TREE"></t> 1506 </a> 1507 ''')) 1508 objectify.xsiannotate(root, ignore_old=False) 1509 1510 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1511 for c in root.iterchildren() ] 1512 self.assertEquals("xsd:integer", child_types[ 0]) 1513 self.assertEquals("xsd:string", child_types[ 1]) 1514 self.assertEquals("xsd:double", child_types[ 2]) 1515 self.assertEquals("xsd:string", child_types[ 3]) 1516 self.assertEquals("xsd:boolean", child_types[ 4]) 1517 self.assertEquals(None, child_types[ 5]) 1518 self.assertEquals(None, child_types[ 6]) 1519 self.assertEquals("xsd:double", child_types[ 7]) 1520 self.assertEquals("xsd:float", child_types[ 8]) 1521 self.assertEquals("xsd:string", child_types[ 9]) 1522 self.assertEquals("xsd:string", child_types[10]) 1523 self.assertEquals("xsd:double", child_types[11]) 1524 self.assertEquals("xsd:integer", child_types[12]) 1525 self.assertEquals(None, child_types[13])
1526
1527 - def test_pyannotate_ignore_old(self):
1528 XML = self.XML 1529 root = XML(_bytes('''\ 1530 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1531 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1532 <b>5</b> 1533 <b>test</b> 1534 <c>1.1</c> 1535 <c>\uF8D2</c> 1536 <x>true</x> 1537 <n xsi:nil="true" /> 1538 <n></n> 1539 <b xsi:type="double">5</b> 1540 <b xsi:type="float">5</b> 1541 <s xsi:type="string">23</s> 1542 <s py:pytype="str">42</s> 1543 <f py:pytype="float">300</f> 1544 <l py:pytype="long">2</l> 1545 <t py:pytype="TREE"></t> 1546 </a> 1547 ''')) 1548 objectify.pyannotate(root, ignore_old=True) 1549 1550 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1551 for c in root.iterchildren() ] 1552 self.assertEquals("int", child_types[ 0]) 1553 self.assertEquals("str", child_types[ 1]) 1554 self.assertEquals("float", child_types[ 2]) 1555 self.assertEquals("str", child_types[ 3]) 1556 self.assertEquals("bool", child_types[ 4]) 1557 self.assertEquals("NoneType", child_types[ 5]) 1558 self.assertEquals(None, child_types[ 6]) 1559 self.assertEquals("float", child_types[ 7]) 1560 self.assertEquals("float", child_types[ 8]) 1561 self.assertEquals("str", child_types[ 9]) 1562 self.assertEquals("int", child_types[10]) 1563 self.assertEquals("int", child_types[11]) 1564 self.assertEquals("int", child_types[12]) 1565 self.assertEquals(None, child_types[13]) 1566 1567 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1568
1569 - def test_pyannotate_empty(self):
1570 XML = self.XML 1571 root = XML('''\ 1572 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1573 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1574 <n></n> 1575 </a> 1576 ''') 1577 objectify.pyannotate(root) 1578 1579 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1580 for c in root.iterchildren() ] 1581 self.assertEquals(None, child_types[0]) 1582 1583 objectify.annotate(root, empty_pytype="str") 1584 1585 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1586 for c in root.iterchildren() ] 1587 self.assertEquals("str", child_types[0])
1588
1589 - def test_pyannotate_use_old(self):
1590 XML = self.XML 1591 root = XML('''\ 1592 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1593 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1594 <b>5</b> 1595 <b>test</b> 1596 <c>1.1</c> 1597 <c>\uF8D2</c> 1598 <x>true</x> 1599 <n xsi:nil="true" /> 1600 <n></n> 1601 <b xsi:type="double">5</b> 1602 <b xsi:type="float">5</b> 1603 <s xsi:type="string">23</s> 1604 <s py:pytype="str">42</s> 1605 <f py:pytype="float">300</f> 1606 <l py:pytype="long">2</l> 1607 <t py:pytype="TREE"></t> 1608 </a> 1609 ''') 1610 objectify.pyannotate(root) 1611 1612 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1613 for c in root.iterchildren() ] 1614 self.assertEquals("int", child_types[ 0]) 1615 self.assertEquals("str", child_types[ 1]) 1616 self.assertEquals("float", child_types[ 2]) 1617 self.assertEquals("str", child_types[ 3]) 1618 self.assertEquals("bool", child_types[ 4]) 1619 self.assertEquals("NoneType", child_types[ 5]) 1620 self.assertEquals(None, child_types[ 6]) 1621 self.assertEquals("float", child_types[ 7]) 1622 self.assertEquals("float", child_types[ 8]) 1623 self.assertEquals("str", child_types[ 9]) 1624 self.assertEquals("str", child_types[10]) 1625 self.assertEquals("float", child_types[11]) 1626 self.assertEquals("int", child_types[12]) 1627 self.assertEquals(TREE_PYTYPE, child_types[13]) 1628 1629 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1630
1631 - def test_xsiannotate_ignore_old(self):
1632 XML = self.XML 1633 root = XML(_bytes('''\ 1634 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1635 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1636 <b>5</b> 1637 <b>test</b> 1638 <c>1.1</c> 1639 <c>\uF8D2</c> 1640 <x>true</x> 1641 <n xsi:nil="true" /> 1642 <n></n> 1643 <b xsi:type="double">5</b> 1644 <b xsi:type="float">5</b> 1645 <s xsi:type="string">23</s> 1646 <s py:pytype="str">42</s> 1647 <f py:pytype="float">300</f> 1648 <l py:pytype="long">2</l> 1649 <t py:pytype="TREE"></t> 1650 </a> 1651 ''')) 1652 objectify.xsiannotate(root, ignore_old=True) 1653 1654 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1655 for c in root.iterchildren() ] 1656 self.assertEquals("xsd:integer", child_types[ 0]) 1657 self.assertEquals("xsd:string", child_types[ 1]) 1658 self.assertEquals("xsd:double", child_types[ 2]) 1659 self.assertEquals("xsd:string", child_types[ 3]) 1660 self.assertEquals("xsd:boolean", child_types[ 4]) 1661 self.assertEquals(None, child_types[ 5]) 1662 self.assertEquals(None, child_types[ 6]) 1663 self.assertEquals("xsd:integer", child_types[ 7]) 1664 self.assertEquals("xsd:integer", child_types[ 8]) 1665 self.assertEquals("xsd:integer", child_types[ 9]) 1666 self.assertEquals("xsd:string", child_types[10]) 1667 self.assertEquals("xsd:double", child_types[11]) 1668 self.assertEquals("xsd:integer", child_types[12]) 1669 self.assertEquals(None, child_types[13]) 1670 1671 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1672
1673 - def test_deannotate(self):
1674 XML = self.XML 1675 root = XML(_bytes('''\ 1676 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1677 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1678 <b>5</b> 1679 <b>test</b> 1680 <c>1.1</c> 1681 <c>\uF8D2</c> 1682 <x>true</x> 1683 <n xsi:nil="true" /> 1684 <n></n> 1685 <b xsi:type="double">5</b> 1686 <b xsi:type="float">5</b> 1687 <s xsi:type="string">23</s> 1688 <s py:pytype="str">42</s> 1689 <f py:pytype="float">300</f> 1690 <l py:pytype="long">2</l> 1691 <t py:pytype="TREE"></t> 1692 </a> 1693 ''')) 1694 objectify.deannotate(root) 1695 1696 for c in root.getiterator(): 1697 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 1698 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1699 1700 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1701
1702 - def test_xsinil_deannotate(self):
1703 XML = self.XML 1704 root = XML(_bytes('''\ 1705 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1706 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1707 <b>5</b> 1708 <b>test</b> 1709 <c>1.1</c> 1710 <c>\uF8D2</c> 1711 <x>true</x> 1712 <n xsi:nil="true" /> 1713 <n></n> 1714 <b xsi:type="double">5</b> 1715 <b xsi:type="float">5</b> 1716 <s xsi:type="string">23</s> 1717 <s py:pytype="str">42</s> 1718 <f py:pytype="float">300</f> 1719 <l py:pytype="long">2</l> 1720 <t py:pytype="TREE"></t> 1721 </a> 1722 ''')) 1723 objectify.annotate( 1724 root, ignore_old=False, ignore_xsi=False, annotate_xsi=True, 1725 empty_pytype='str', empty_type='string') 1726 objectify.deannotate(root, pytype=False, xsi=False, xsi_nil=True) 1727 1728 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1729 for c in root.iterchildren() ] 1730 self.assertEquals("xsd:integer", child_types[ 0]) 1731 self.assertEquals("xsd:string", child_types[ 1]) 1732 self.assertEquals("xsd:double", child_types[ 2]) 1733 self.assertEquals("xsd:string", child_types[ 3]) 1734 self.assertEquals("xsd:boolean", child_types[ 4]) 1735 self.assertEquals(None, child_types[ 5]) 1736 self.assertEquals("xsd:string", child_types[ 6]) 1737 self.assertEquals("xsd:double", child_types[ 7]) 1738 self.assertEquals("xsd:float", child_types[ 8]) 1739 self.assertEquals("xsd:string", child_types[ 9]) 1740 self.assertEquals("xsd:string", child_types[10]) 1741 self.assertEquals("xsd:double", child_types[11]) 1742 self.assertEquals("xsd:integer", child_types[12]) 1743 self.assertEquals(None, child_types[13]) 1744 1745 self.assertEquals(None, root.n.get(XML_SCHEMA_NIL_ATTR)) 1746 1747 for c in root.iterchildren(): 1748 self.assertNotEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1749 # these have no equivalent in xsi:type 1750 if (c.get(objectify.PYTYPE_ATTRIBUTE) not in [TREE_PYTYPE, 1751 "NoneType"]): 1752 self.assertNotEquals( 1753 None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))
1754
1755 - def test_xsitype_deannotate(self):
1756 XML = self.XML 1757 root = XML(_bytes('''\ 1758 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1759 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1760 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1761 <b>5</b> 1762 <b>test</b> 1763 <c>1.1</c> 1764 <c>\uF8D2</c> 1765 <x>true</x> 1766 <n xsi:nil="true" /> 1767 <n></n> 1768 <b xsi:type="xsd:double">5</b> 1769 <b xsi:type="xsd:float">5</b> 1770 <s xsi:type="xsd:string">23</s> 1771 <s py:pytype="str">42</s> 1772 <f py:pytype="float">300</f> 1773 <l py:pytype="long">2</l> 1774 <t py:pytype="TREE"></t> 1775 </a> 1776 ''')) 1777 objectify.annotate(root) 1778 objectify.deannotate(root, pytype=False) 1779 1780 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1781 for c in root.iterchildren() ] 1782 self.assertEquals("int", child_types[ 0]) 1783 self.assertEquals("str", child_types[ 1]) 1784 self.assertEquals("float", child_types[ 2]) 1785 self.assertEquals("str", child_types[ 3]) 1786 self.assertEquals("bool", child_types[ 4]) 1787 self.assertEquals("NoneType", child_types[ 5]) 1788 self.assertEquals(None, child_types[ 6]) 1789 self.assertEquals("float", child_types[ 7]) 1790 self.assertEquals("float", child_types[ 8]) 1791 self.assertEquals("str", child_types[ 9]) 1792 self.assertEquals("int", child_types[10]) 1793 self.assertEquals("int", child_types[11]) 1794 self.assertEquals("int", child_types[12]) 1795 self.assertEquals(None, child_types[13]) 1796 1797 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1798 1799 for c in root.getiterator(): 1800 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))
1801
1802 - def test_pytype_deannotate(self):
1803 XML = self.XML 1804 root = XML(_bytes('''\ 1805 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1806 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1807 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1808 <b xsi:type="xsd:int">5</b> 1809 <b xsi:type="xsd:string">test</b> 1810 <c xsi:type="xsd:float">1.1</c> 1811 <c xsi:type="xsd:string">\uF8D2</c> 1812 <x xsi:type="xsd:boolean">true</x> 1813 <n xsi:nil="true" /> 1814 <n></n> 1815 <b xsi:type="xsd:double">5</b> 1816 <b xsi:type="xsd:float">5</b> 1817 <s xsi:type="xsd:string">23</s> 1818 <s xsi:type="xsd:string">42</s> 1819 <f xsi:type="xsd:float">300</f> 1820 <l xsi:type="xsd:long">2</l> 1821 <t py:pytype="TREE"></t> 1822 </a> 1823 ''')) 1824 objectify.annotate(root) 1825 objectify.deannotate(root, xsi=False) 1826 1827 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1828 for c in root.iterchildren() ] 1829 self.assertEquals("xsd:int", child_types[ 0]) 1830 self.assertEquals("xsd:string", child_types[ 1]) 1831 self.assertEquals("xsd:float", child_types[ 2]) 1832 self.assertEquals("xsd:string", child_types[ 3]) 1833 self.assertEquals("xsd:boolean", child_types[ 4]) 1834 self.assertEquals(None, child_types[ 5]) 1835 self.assertEquals(None, child_types[ 6]) 1836 self.assertEquals("xsd:double", child_types[ 7]) 1837 self.assertEquals("xsd:float", child_types[ 8]) 1838 self.assertEquals("xsd:string", child_types[ 9]) 1839 self.assertEquals("xsd:string", child_types[10]) 1840 self.assertEquals("xsd:float", child_types[11]) 1841 self.assertEquals("xsd:long", child_types[12]) 1842 self.assertEquals(None, child_types[13]) 1843 1844 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1845 1846 for c in root.getiterator(): 1847 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1848
1849 - def test_change_pytype_attribute(self):
1850 XML = self.XML 1851 1852 xml = _bytes('''\ 1853 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1854 <b>5</b> 1855 <b>test</b> 1856 <c>1.1</c> 1857 <c>\uF8D2</c> 1858 <x>true</x> 1859 <n xsi:nil="true" /> 1860 <n></n> 1861 <b xsi:type="double">5</b> 1862 </a> 1863 ''') 1864 1865 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1866 objectify.set_pytype_attribute_tag("{TEST}test") 1867 1868 root = XML(xml) 1869 objectify.annotate(root) 1870 1871 attribs = root.xpath("//@py:%s" % pytype_name, 1872 namespaces={"py" : pytype_ns}) 1873 self.assertEquals(0, len(attribs)) 1874 attribs = root.xpath("//@py:test", 1875 namespaces={"py" : "TEST"}) 1876 self.assertEquals(7, len(attribs)) 1877 1878 objectify.set_pytype_attribute_tag() 1879 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1880 1881 self.assertNotEqual("test", pytype_ns.lower()) 1882 self.assertNotEqual("test", pytype_name.lower()) 1883 1884 root = XML(xml) 1885 attribs = root.xpath("//@py:%s" % pytype_name, 1886 namespaces={"py" : pytype_ns}) 1887 self.assertEquals(0, len(attribs)) 1888 1889 objectify.annotate(root) 1890 attribs = root.xpath("//@py:%s" % pytype_name, 1891 namespaces={"py" : pytype_ns}) 1892 self.assertEquals(7, len(attribs))
1893
1894 - def test_registered_types(self):
1895 orig_types = objectify.getRegisteredTypes() 1896 orig_types[0].unregister() 1897 self.assertEquals(orig_types[1:], objectify.getRegisteredTypes()) 1898 1899 class NewType(objectify.ObjectifiedDataElement): 1900 pass
1901 1902 def checkMyType(s): 1903 return True 1904 1905 pytype = objectify.PyType("mytype", checkMyType, NewType) 1906 self.assert_(pytype not in objectify.getRegisteredTypes()) 1907 pytype.register() 1908 self.assert_(pytype in objectify.getRegisteredTypes()) 1909 pytype.unregister() 1910 self.assert_(pytype not in objectify.getRegisteredTypes()) 1911 1912 pytype.register(before = [objectify.getRegisteredTypes()[0].name]) 1913 self.assertEquals(pytype, objectify.getRegisteredTypes()[0]) 1914 pytype.unregister() 1915 1916 pytype.register(after = [objectify.getRegisteredTypes()[0].name]) 1917 self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0]) 1918 pytype.unregister() 1919 1920 self.assertRaises(ValueError, pytype.register, 1921 before = [objectify.getRegisteredTypes()[0].name], 1922 after = [objectify.getRegisteredTypes()[1].name]) 1923
1924 - def test_registered_type_stringify(self):
1925 from datetime import datetime 1926 def parse_date(value): 1927 if len(value) != 14: 1928 raise ValueError(value) 1929 Y = int(value[0:4]) 1930 M = int(value[4:6]) 1931 D = int(value[6:8]) 1932 h = int(value[8:10]) 1933 m = int(value[10:12]) 1934 s = int(value[12:14]) 1935 return datetime(Y, M, D, h, m, s)
1936 1937 def stringify_date(date): 1938 return date.strftime("%Y%m%d%H%M%S") 1939 1940 class DatetimeElement(objectify.ObjectifiedDataElement): 1941 def pyval(self): 1942 return parse_date(self.text) 1943 pyval = property(pyval) 1944 1945 datetime_type = objectify.PyType( 1946 "datetime", parse_date, DatetimeElement, stringify_date) 1947 datetime_type.xmlSchemaTypes = "dateTime" 1948 datetime_type.register() 1949 1950 NAMESPACE = "http://foo.net/xmlns" 1951 NAMESPACE_MAP = {'ns': NAMESPACE} 1952 1953 r = objectify.Element("{%s}root" % NAMESPACE, nsmap=NAMESPACE_MAP) 1954 time = datetime.now() 1955 r.date = time 1956 1957 self.assert_(isinstance(r.date, DatetimeElement)) 1958 self.assert_(isinstance(r.date.pyval, datetime)) 1959 1960 self.assertEquals(r.date.pyval, parse_date(stringify_date(time))) 1961 self.assertEquals(r.date.text, stringify_date(time)) 1962 1963 r.date = objectify.E.date(time) 1964 1965 self.assert_(isinstance(r.date, DatetimeElement)) 1966 self.assert_(isinstance(r.date.pyval, datetime)) 1967 1968 self.assertEquals(r.date.pyval, parse_date(stringify_date(time))) 1969 self.assertEquals(r.date.text, stringify_date(time)) 1970
1971 - def test_object_path(self):
1972 root = self.XML(xml_str) 1973 path = objectify.ObjectPath( "root.c1.c2" ) 1974 self.assertEquals(root.c1.c2.text, path.find(root).text) 1975 self.assertEquals(root.c1.c2.text, path(root).text)
1976
1977 - def test_object_path_list(self):
1978 root = self.XML(xml_str) 1979 path = objectify.ObjectPath( ['root', 'c1', 'c2'] ) 1980 self.assertEquals(root.c1.c2.text, path.find(root).text) 1981 self.assertEquals(root.c1.c2.text, path(root).text)
1982
1983 - def test_object_path_fail(self):
1984 root = self.XML(xml_str) 1985 path = objectify.ObjectPath( "root.c1.c99" ) 1986 self.assertRaises(AttributeError, path, root)
1987
1988 - def test_object_path_default_absolute(self):
1989 root = self.XML(xml_str) 1990 path = objectify.ObjectPath( "root.c1.c99" ) 1991 self.assertEquals(None, path(root, None)) 1992 path = objectify.ObjectPath( "root.c99.c2" ) 1993 self.assertEquals(None, path(root, None)) 1994 path = objectify.ObjectPath( "notroot.c99.c2" ) 1995 self.assertEquals(None, path(root, None))
1996
1997 - def test_object_path_default_relative(self):
1998 root = self.XML(xml_str) 1999 path = objectify.ObjectPath( ".c1.c99" ) 2000 self.assertEquals(None, path(root, None)) 2001 path = objectify.ObjectPath( ".c99.c2" ) 2002 self.assertEquals(None, path(root, None))
2003
2004 - def test_object_path_syntax(self):
2005 root = self.XML(xml_str) 2006 path = objectify.ObjectPath("root . {objectified}c1. c2") 2007 self.assertEquals(root.c1.c2.text, path(root).text) 2008 2009 path = objectify.ObjectPath(" root.{objectified} c1.c2 [ 0 ] ") 2010 self.assertEquals(root.c1.c2.text, path(root).text)
2011
2012 - def test_object_path_fail_parse_empty(self):
2013 self.assertRaises(ValueError, objectify.ObjectPath, "")
2014
2015 - def test_object_path_fail_parse_empty_list(self):
2016 self.assertRaises(ValueError, objectify.ObjectPath, [])
2017
2018 - def test_object_path_hasattr(self):
2019 root = self.XML(xml_str) 2020 path = objectify.ObjectPath( "root" ) 2021 self.assert_(path.hasattr(root)) 2022 path = objectify.ObjectPath( "root.c1" ) 2023 self.assert_(path.hasattr(root)) 2024 path = objectify.ObjectPath( "root.c1.c2" ) 2025 self.assert_(path.hasattr(root)) 2026 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 2027 self.assert_(path.hasattr(root)) 2028 path = objectify.ObjectPath( "root.c1.c2[1]" ) 2029 self.assert_(path.hasattr(root)) 2030 path = objectify.ObjectPath( "root.c1.c2[2]" ) 2031 self.assert_(path.hasattr(root)) 2032 path = objectify.ObjectPath( "root.c1.c2[3]" ) 2033 self.assertFalse(path.hasattr(root)) 2034 path = objectify.ObjectPath( "root.c1[1].c2" ) 2035 self.assertFalse(path.hasattr(root))
2036
2037 - def test_object_path_dot(self):
2038 root = self.XML(xml_str) 2039 path = objectify.ObjectPath( "." ) 2040 self.assertEquals(root.c1.c2.text, path(root).c1.c2.text)
2041
2042 - def test_object_path_dot_list(self):
2043 root = self.XML(xml_str) 2044 path = objectify.ObjectPath( [''] ) 2045 self.assertEquals(root.c1.c2.text, path(root).c1.c2.text)
2046
2047 - def test_object_path_dot_root(self):
2048 root = self.XML(xml_str) 2049 path = objectify.ObjectPath( ".c1.c2" ) 2050 self.assertEquals(root.c1.c2.text, path(root).text)
2051
2052 - def test_object_path_dot_root_list(self):
2053 root = self.XML(xml_str) 2054 path = objectify.ObjectPath( ['', 'c1', 'c2'] ) 2055 self.assertEquals(root.c1.c2.text, path(root).text)
2056
2057 - def test_object_path_index(self):
2058 root = self.XML(xml_str) 2059 path = objectify.ObjectPath( "root.c1[0].c2[0]" ) 2060 self.assertEquals(root.c1.c2.text, path(root).text) 2061 2062 path = objectify.ObjectPath( "root.c1[0].c2" ) 2063 self.assertEquals(root.c1.c2.text, path(root).text) 2064 2065 path = objectify.ObjectPath( "root.c1[0].c2[1]" ) 2066 self.assertEquals(root.c1.c2[1].text, path(root).text) 2067 2068 path = objectify.ObjectPath( "root.c1.c2[2]" ) 2069 self.assertEquals(root.c1.c2[2].text, path(root).text) 2070 2071 path = objectify.ObjectPath( "root.c1.c2[-1]" ) 2072 self.assertEquals(root.c1.c2[-1].text, path(root).text) 2073 2074 path = objectify.ObjectPath( "root.c1.c2[-3]" ) 2075 self.assertEquals(root.c1.c2[-3].text, path(root).text)
2076
2077 - def test_object_path_index_list(self):
2078 root = self.XML(xml_str) 2079 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] ) 2080 self.assertEquals(root.c1.c2.text, path(root).text) 2081 2082 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] ) 2083 self.assertEquals(root.c1.c2[2].text, path(root).text) 2084 2085 path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] ) 2086 self.assertEquals(root.c1.c2[2].text, path(root).text) 2087 2088 path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] ) 2089 self.assertEquals(root.c1.c2[-1].text, path(root).text) 2090 2091 path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] ) 2092 self.assertEquals(root.c1.c2[-3].text, path(root).text)
2093
2094 - def test_object_path_index_fail_parse(self):
2095 self.assertRaises(ValueError, objectify.ObjectPath, 2096 "root.c1[0].c2[-1-2]") 2097 self.assertRaises(ValueError, objectify.ObjectPath, 2098 ['root', 'c1[0]', 'c2[-1-2]']) 2099 2100 self.assertRaises(ValueError, objectify.ObjectPath, 2101 "root[2].c1.c2") 2102 self.assertRaises(ValueError, objectify.ObjectPath, 2103 ['root[2]', 'c1', 'c2']) 2104 2105 self.assertRaises(ValueError, objectify.ObjectPath, 2106 []) 2107 self.assertRaises(ValueError, objectify.ObjectPath, 2108 ['', '', ''])
2109
2110 - def test_object_path_index_fail_lookup(self):
2111 root = self.XML(xml_str) 2112 path = objectify.ObjectPath("root.c1[9999].c2") 2113 self.assertRaises(AttributeError, path, root) 2114 2115 path = objectify.ObjectPath("root.c1[0].c2[9999]") 2116 self.assertRaises(AttributeError, path, root) 2117 2118 path = objectify.ObjectPath(".c1[9999].c2[0]") 2119 self.assertRaises(AttributeError, path, root) 2120 2121 path = objectify.ObjectPath("root.c1[-2].c2") 2122 self.assertRaises(AttributeError, path, root) 2123 2124 path = objectify.ObjectPath("root.c1[0].c2[-4]") 2125 self.assertRaises(AttributeError, path, root)
2126
2127 - def test_object_path_ns(self):
2128 root = self.XML(xml_str) 2129 path = objectify.ObjectPath( "{objectified}root.c1.c2" ) 2130 self.assertEquals(root.c1.c2.text, path.find(root).text) 2131 path = objectify.ObjectPath( "{objectified}root.{objectified}c1.c2" ) 2132 self.assertEquals(root.c1.c2.text, path.find(root).text) 2133 path = objectify.ObjectPath( "root.{objectified}c1.{objectified}c2" ) 2134 self.assertEquals(root.c1.c2.text, path.find(root).text) 2135 path = objectify.ObjectPath( "root.c1.{objectified}c2" ) 2136 self.assertEquals(root.c1.c2.text, path.find(root).text) 2137 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 2138 self.assertEquals(getattr(root.c1, '{otherNS}c2').text, 2139 path.find(root).text)
2140
2141 - def test_object_path_ns_list(self):
2142 root = self.XML(xml_str) 2143 path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] ) 2144 self.assertEquals(root.c1.c2.text, path.find(root).text) 2145 path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] ) 2146 self.assertEquals(root.c1.c2.text, path.find(root).text) 2147 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] ) 2148 self.assertEquals(root.c1.c2.text, path.find(root).text) 2149 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] ) 2150 self.assertEquals(root.c1.c2[2].text, path.find(root).text) 2151 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] ) 2152 self.assertEquals(root.c1.c2.text, path.find(root).text) 2153 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] ) 2154 self.assertEquals(root.c1.c2[2].text, path.find(root).text) 2155 path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] ) 2156 self.assertEquals(getattr(root.c1, '{otherNS}c2').text, 2157 path.find(root).text)
2158
2159 - def test_object_path_set(self):
2160 root = self.XML(xml_str) 2161 path = objectify.ObjectPath( "root.c1.c2" ) 2162 self.assertEquals(root.c1.c2.text, path.find(root).text) 2163 self.assertEquals("1", root.c1.c2[1].text) 2164 2165 new_value = "my new value" 2166 path.setattr(root, new_value) 2167 2168 self.assertEquals(new_value, root.c1.c2.text) 2169 self.assertEquals(new_value, path(root).text) 2170 self.assertEquals("1", root.c1.c2[1].text)
2171
2172 - def test_object_path_set_element(self):
2173 root = self.XML(xml_str) 2174 path = objectify.ObjectPath( "root.c1.c2" ) 2175 self.assertEquals(root.c1.c2.text, path.find(root).text) 2176 self.assertEquals("1", root.c1.c2[1].text) 2177 2178 new_el = self.Element("{objectified}test") 2179 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2180 path.setattr(root, new_el.sub) 2181 2182 self.assertEquals("ATTR", root.c1.c2.get("myattr")) 2183 self.assertEquals("TEST", root.c1.c2.a.text) 2184 self.assertEquals("TEST", path(root).a.text) 2185 self.assertEquals("1", root.c1.c2[1].text)
2186
2187 - def test_object_path_set_create(self):
2188 root = self.XML(xml_str) 2189 path = objectify.ObjectPath( "root.c1.c99" ) 2190 self.assertRaises(AttributeError, path.find, root) 2191 2192 new_value = "my new value" 2193 path.setattr(root, new_value) 2194 2195 self.assertEquals(1, len(root.c1.c99)) 2196 self.assertEquals(new_value, root.c1.c99.text) 2197 self.assertEquals(new_value, path(root).text)
2198
2199 - def test_object_path_set_create_element(self):
2200 root = self.XML(xml_str) 2201 path = objectify.ObjectPath( "root.c1.c99" ) 2202 self.assertRaises(AttributeError, path.find, root) 2203 2204 new_el = self.Element("{objectified}test") 2205 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2206 path.setattr(root, new_el.sub) 2207 2208 self.assertEquals(1, len(root.c1.c99)) 2209 self.assertEquals("ATTR", root.c1.c99.get("myattr")) 2210 self.assertEquals("TEST", root.c1.c99.a.text) 2211 self.assertEquals("TEST", path(root).a.text)
2212
2213 - def test_object_path_set_create_list(self):
2214 root = self.XML(xml_str) 2215 path = objectify.ObjectPath( "root.c1.c99" ) 2216 self.assertRaises(AttributeError, path.find, root) 2217 2218 new_el = self.Element("{objectified}test") 2219 new_el.a = ["TEST1", "TEST2"] 2220 new_el.a[0].set("myattr", "ATTR1") 2221 new_el.a[1].set("myattr", "ATTR2") 2222 2223 path.setattr(root, list(new_el.a)) 2224 2225 self.assertEquals(2, len(root.c1.c99)) 2226 self.assertEquals("ATTR1", root.c1.c99[0].get("myattr")) 2227 self.assertEquals("TEST1", root.c1.c99[0].text) 2228 self.assertEquals("ATTR2", root.c1.c99[1].get("myattr")) 2229 self.assertEquals("TEST2", root.c1.c99[1].text) 2230 self.assertEquals("TEST1", path(root).text)
2231
2232 - def test_object_path_addattr(self):
2233 root = self.XML(xml_str) 2234 path = objectify.ObjectPath( "root.c1.c2" ) 2235 self.assertEquals(3, len(root.c1.c2)) 2236 path.addattr(root, "test") 2237 self.assertEquals(4, len(root.c1.c2)) 2238 self.assertEquals(["0", "1", "2", "test"], 2239 [el.text for el in root.c1.c2])
2240
2241 - def test_object_path_addattr_element(self):
2242 root = self.XML(xml_str) 2243 path = objectify.ObjectPath( "root.c1.c2" ) 2244 self.assertEquals(3, len(root.c1.c2)) 2245 2246 new_el = self.Element("{objectified}test") 2247 etree.SubElement(new_el, "{objectified}sub").a = "TEST" 2248 2249 path.addattr(root, new_el.sub) 2250 self.assertEquals(4, len(root.c1.c2)) 2251 self.assertEquals("TEST", root.c1.c2[3].a.text) 2252 self.assertEquals(["0", "1", "2"], 2253 [el.text for el in root.c1.c2[:3]])
2254
2255 - def test_object_path_addattr_create(self):
2256 root = self.XML(xml_str) 2257 path = objectify.ObjectPath( "root.c1.c99" ) 2258 self.assertRaises(AttributeError, path.find, root) 2259 2260 new_value = "my new value" 2261 path.addattr(root, new_value) 2262 2263 self.assertEquals(1, len(root.c1.c99)) 2264 self.assertEquals(new_value, root.c1.c99.text) 2265 self.assertEquals(new_value, path(root).text)
2266
2267 - def test_object_path_addattr_create_element(self):
2268 root = self.XML(xml_str) 2269 path = objectify.ObjectPath( "root.c1.c99" ) 2270 self.assertRaises(AttributeError, path.find, root) 2271 2272 new_el = self.Element("{objectified}test") 2273 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2274 2275 path.addattr(root, new_el.sub) 2276 self.assertEquals(1, len(root.c1.c99)) 2277 self.assertEquals("TEST", root.c1.c99.a.text) 2278 self.assertEquals("TEST", path(root).a.text) 2279 self.assertEquals("ATTR", root.c1.c99.get("myattr"))
2280
2281 - def test_object_path_addattr_create_list(self):
2282 root = self.XML(xml_str) 2283 path = objectify.ObjectPath( "root.c1.c99" ) 2284 self.assertRaises(AttributeError, path.find, root) 2285 2286 new_el = self.Element("{objectified}test") 2287 new_el.a = ["TEST1", "TEST2"] 2288 2289 self.assertEquals(2, len(new_el.a)) 2290 2291 path.addattr(root, list(new_el.a)) 2292 self.assertEquals(2, len(root.c1.c99)) 2293 self.assertEquals("TEST1", root.c1.c99.text) 2294 self.assertEquals("TEST2", path(root)[1].text)
2295
2296 - def test_descendant_paths(self):
2297 root = self.XML(xml_str) 2298 self.assertEquals( 2299 ['{objectified}root', '{objectified}root.c1', 2300 '{objectified}root.c1.c2', 2301 '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]', 2302 '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'], 2303 root.descendantpaths())
2304
2305 - def test_descendant_paths_child(self):
2306 root = self.XML(xml_str) 2307 self.assertEquals( 2308 ['{objectified}c1', '{objectified}c1.c2', 2309 '{objectified}c1.c2[1]', '{objectified}c1.c2[2]', 2310 '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'], 2311 root.c1.descendantpaths())
2312
2313 - def test_descendant_paths_prefix(self):
2314 root = self.XML(xml_str) 2315 self.assertEquals( 2316 ['root.{objectified}c1', 'root.{objectified}c1.c2', 2317 'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]', 2318 'root.{objectified}c1.{otherNS}c2', 2319 'root.{objectified}c1.{}c2'], 2320 root.c1.descendantpaths('root'))
2321
2322 - def test_pickle(self):
2323 import pickle 2324 2325 root = self.XML(xml_str) 2326 out = BytesIO() 2327 pickle.dump(root, out) 2328 2329 new_root = pickle.loads(out.getvalue()) 2330 self.assertEquals( 2331 etree.tostring(new_root), 2332 etree.tostring(root))
2333
2334 - def test_pickle_elementtree(self):
2335 import pickle 2336 2337 tree = etree.ElementTree(self.XML(xml_str + "<?my pi?>")) 2338 out = BytesIO() 2339 pickle.dump(tree, out) 2340 2341 new_tree = pickle.loads(out.getvalue()) 2342 self.assert_(isinstance(new_tree, etree._ElementTree)) 2343 self.assertEquals( 2344 etree.tostring(new_tree), 2345 etree.tostring(tree))
2346
2347 - def test_pickle_intelement(self):
2348 self._test_pickle('<x>42</x>') 2349 self._test_pickle(objectify.DataElement(42))
2350
2351 - def test_pickle_floattelement(self):
2352 self._test_pickle('<x>42.0</x>') 2353 self._test_pickle(objectify.DataElement(42.0))
2354
2355 - def test_pickle_strelement(self):
2356 self._test_pickle('<x>Pickle me!</x>') 2357 self._test_pickle(objectify.DataElement('Pickle me!'))
2358
2359 - def test_pickle_boolelement(self):
2360 self._test_pickle('<x>true</x>') 2361 self._test_pickle('<x>false</x>') 2362 self._test_pickle(objectify.DataElement(True)) 2363 self._test_pickle(objectify.DataElement(False))
2364
2365 - def test_pickle_noneelement(self):
2366 self._test_pickle(''' 2367 <x xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>''') 2368 self._test_pickle(objectify.DataElement(None))
2369
2370 - def _test_pickle(self, stringOrElt):
2371 import pickle 2372 if isinstance(stringOrElt, (etree._Element, etree._ElementTree)): 2373 elt = stringOrElt 2374 else: 2375 elt = self.XML(stringOrElt) 2376 out = BytesIO() 2377 pickle.dump(elt, out) 2378 2379 new_elt = pickle.loads(out.getvalue()) 2380 self.assertEquals( 2381 etree.tostring(new_elt), 2382 etree.tostring(elt))
2383 2384 # E-Factory tests, need to use sub-elements as root element is always 2385 # type-looked-up as ObjectifiedElement (no annotations)
2386 - def test_efactory_int(self):
2387 E = objectify.E 2388 root = E.root(E.val(23)) 2389 self.assert_(isinstance(root.val, objectify.IntElement))
2390
2391 - def test_efactory_float(self):
2392 E = objectify.E 2393 root = E.root(E.val(233.23)) 2394 self.assert_(isinstance(root.val, objectify.FloatElement))
2395
2396 - def test_efactory_str(self):
2397 E = objectify.E 2398 root = E.root(E.val("what?")) 2399 self.assert_(isinstance(root.val, objectify.StringElement))
2400
2401 - def test_efactory_unicode(self):
2402 E = objectify.E 2403 root = E.root(E.val(_str("blöödy häll", encoding="ISO-8859-1"))) 2404 self.assert_(isinstance(root.val, objectify.StringElement))
2405
2406 - def test_efactory_bool(self):
2407 E = objectify.E 2408 root = E.root(E.val(True)) 2409 self.assert_(isinstance(root.val, objectify.BoolElement))
2410
2411 - def test_efactory_none(self):
2412 E = objectify.E 2413 root = E.root(E.val(None)) 2414 self.assert_(isinstance(root.val, objectify.NoneElement))
2415
2416 - def test_efactory_value_concatenation(self):
2417 E = objectify.E 2418 root = E.root(E.val(1, "foo", 2.0, "bar ", True, None)) 2419 self.assert_(isinstance(root.val, objectify.StringElement))
2420
2421 - def test_efactory_attrib(self):
2422 E = objectify.E 2423 root = E.root(foo="bar") 2424 self.assertEquals(root.get("foo"), "bar")
2425
2426 - def test_efactory_nested(self):
2427 E = objectify.E 2428 DataElement = objectify.DataElement 2429 root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1), 2430 DataElement(2.0)) 2431 self.assert_(isinstance(root, objectify.ObjectifiedElement)) 2432 self.assertEquals(root.text, "text") 2433 self.assert_(isinstance(root.sub, objectify.ObjectifiedElement)) 2434 self.assertEquals(root.sub.tail, "tail") 2435 self.assert_(isinstance(root.sub.subsub, objectify.StringElement)) 2436 self.assertEquals(len(root.value), 2) 2437 self.assert_(isinstance(root.value[0], objectify.IntElement)) 2438 self.assert_(isinstance(root.value[1], objectify.FloatElement))
2439
2440 - def test_efactory_subtype(self):
2441 class Attribute(objectify.ObjectifiedDataElement): 2442 def __init__(self): 2443 objectify.ObjectifiedDataElement.__init__(self) 2444 self.set("datatype", "TYPE") 2445 self.set("range", "0.,1.")
2446 2447 attr = Attribute() 2448 self.assertEquals(attr.text, None) 2449 self.assertEquals(attr.get("datatype"), "TYPE") 2450 self.assertEquals(attr.get("range"), "0.,1.") 2451
2452 - def test_XML_base_url_docinfo(self):
2453 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2454 docinfo = root.getroottree().docinfo 2455 self.assertEquals(docinfo.URL, "http://no/such/url")
2456
2457 - def test_XML_set_base_url_docinfo(self):
2458 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2459 docinfo = root.getroottree().docinfo 2460 self.assertEquals(docinfo.URL, "http://no/such/url") 2461 docinfo.URL = "https://secret/url" 2462 self.assertEquals(docinfo.URL, "https://secret/url")
2463
2464 - def test_parse_stringio_base_url(self):
2465 tree = objectify.parse(BytesIO("<root/>"), base_url="http://no/such/url") 2466 docinfo = tree.docinfo 2467 self.assertEquals(docinfo.URL, "http://no/such/url")
2468
2469 - def test_parse_base_url_docinfo(self):
2470 tree = objectify.parse(fileInTestDir('include/test_xinclude.xml'), 2471 base_url="http://no/such/url") 2472 docinfo = tree.docinfo 2473 self.assertEquals(docinfo.URL, "http://no/such/url")
2474
2475 - def test_xml_base(self):
2476 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2477 self.assertEquals(root.base, "http://no/such/url") 2478 self.assertEquals( 2479 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2480 root.base = "https://secret/url" 2481 self.assertEquals(root.base, "https://secret/url") 2482 self.assertEquals( 2483 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2484 "https://secret/url")
2485
2486 - def test_xml_base_attribute(self):
2487 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2488 self.assertEquals(root.base, "http://no/such/url") 2489 self.assertEquals( 2490 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2491 root.set('{http://www.w3.org/XML/1998/namespace}base', 2492 "https://secret/url") 2493 self.assertEquals(root.base, "https://secret/url") 2494 self.assertEquals( 2495 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2496 "https://secret/url")
2497
2498 - def test_standard_lookup(self):
2499 XML = self.XML 2500 2501 xml = _bytes('''\ 2502 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 2503 <i>5</i> 2504 <i>-5</i> 2505 <l>4294967296</l> 2506 <l>-4294967296</l> 2507 <f>1.1</f> 2508 <b>true</b> 2509 <b>false</b> 2510 <s>Strange things happen, where strings collide</s> 2511 <s>True</s> 2512 <s>False</s> 2513 <s>t</s> 2514 <s>f</s> 2515 <s></s> 2516 <s>None</s> 2517 <n xsi:nil="true" /> 2518 </root> 2519 ''') 2520 root = XML(xml) 2521 2522 for i in root.i: 2523 self.assert_(isinstance(i, objectify.IntElement)) 2524 for l in root.l: 2525 self.assert_(isinstance(l, objectify.IntElement)) 2526 for f in root.f: 2527 self.assert_(isinstance(f, objectify.FloatElement)) 2528 for b in root.b: 2529 self.assert_(isinstance(b, objectify.BoolElement)) 2530 self.assertEquals(True, root.b[0]) 2531 self.assertEquals(False, root.b[1]) 2532 for s in root.s: 2533 self.assert_(isinstance(s, objectify.StringElement)) 2534 self.assert_(isinstance(root.n, objectify.NoneElement)) 2535 self.assertEquals(None, root.n)
2536
2537 -def test_suite():
2538 suite = unittest.TestSuite() 2539 suite.addTests([unittest.makeSuite(ObjectifyTestCase)]) 2540 suite.addTests(doctest.DocTestSuite(objectify)) 2541 if sys.version_info >= (2,4): 2542 suite.addTests( 2543 [make_doctest('../../../doc/objectify.txt')]) 2544 return suite
2545 2546 if __name__ == '__main__': 2547 print('to test use test.py %s' % __file__) 2548