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>4</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.assertEqual(elt.nsmap, DEFAULT_NSMAP)
110
111 - def test_element_nsmap_empty(self):
112 nsmap = {} 113 elt = objectify.Element("test", nsmap=nsmap) 114 self.assertEqual(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.assertEqual(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.assertTrue(PYTYPE_NAMESPACE in elt.nsmap.values()) 129 for prefix, ns in nsmap.items(): 130 self.assertTrue(prefix in elt.nsmap) 131 self.assertEqual(nsmap[prefix], elt.nsmap[prefix])
132
134 root = objectify.Element("root") 135 root.sub = objectify.Element("test") 136 self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP)
137
139 root = objectify.Element("root") 140 nsmap = {} 141 root.sub = objectify.Element("test", nsmap=nsmap) 142 self.assertEqual(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.assertEqual(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.assertEqual(root.sub.nsmap, expected)
162
164 value = objectify.DataElement("test this") 165 self.assertEqual(value.nsmap, DEFAULT_NSMAP)
166
168 nsmap = {} 169 value = objectify.DataElement("test this", nsmap=nsmap) 170 self.assertEqual(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.assertEqual(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.assertTrue(PYTYPE_NAMESPACE in value.nsmap.values()) 185 for prefix, ns in nsmap.items(): 186 self.assertTrue(prefix in value.nsmap) 187 self.assertEqual(nsmap[prefix], value.nsmap[prefix])
188
190 root = objectify.Element("root") 191 root.value = objectify.DataElement("test this") 192 self.assertEqual(root.value.nsmap, DEFAULT_NSMAP)
193
195 root = objectify.Element("root") 196 nsmap = {} 197 root.value = objectify.DataElement("test this", nsmap=nsmap) 198 self.assertEqual(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.assertEqual(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.assertEqual(root.value.nsmap, expected)
218
220 # ObjectifiedDataElement can also be used as E-Factory 221 value = objectify.ObjectifiedDataElement('test', 'toast') 222 self.assertEqual(value.text, 'testtoast')
223
225 # ObjectifiedDataElement can also be used as E-Factory 226 value = objectify.ObjectifiedElement(objectify.ObjectifiedDataElement(), 'test', 'toast') 227 self.assertEqual(value.ObjectifiedDataElement.tail, 'testtoast')
228
230 # keyword arguments override attrib entries 231 value = objectify.DataElement(23, _pytype="str", _xsi="foobar", 232 attrib={"gnu": "muh", "cat": "meeow", 233 "dog": "wuff"}, 234 bird="tchilp", dog="grrr") 235 self.assertEqual(value.get("gnu"), "muh") 236 self.assertEqual(value.get("cat"), "meeow") 237 self.assertEqual(value.get("dog"), "grrr") 238 self.assertEqual(value.get("bird"), "tchilp")
239
241 # Check that DataElement preserves all attributes ObjectifiedDataElement 242 # arguments 243 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 244 attrib={"gnu": "muh", "cat": "meeow", 245 "dog": "wuff"}, 246 bird="tchilp", dog="grrr") 247 value = objectify.DataElement(arg) 248 self.assertTrue(isinstance(value, objectify.StringElement)) 249 for attr in arg.attrib: 250 self.assertEqual(value.get(attr), arg.get(attr))
251
253 # Check that _pytype arg overrides original py:pytype of 254 # ObjectifiedDataElement 255 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 256 attrib={"gnu": "muh", "cat": "meeow", 257 "dog": "wuff"}, 258 bird="tchilp", dog="grrr") 259 value = objectify.DataElement(arg, _pytype="NoneType") 260 self.assertTrue(isinstance(value, objectify.NoneElement)) 261 self.assertEqual(value.get(XML_SCHEMA_NIL_ATTR), "true") 262 self.assertEqual(value.text, None) 263 self.assertEqual(value.pyval, None) 264 for attr in arg.attrib: 265 #if not attr == objectify.PYTYPE_ATTRIBUTE: 266 self.assertEqual(value.get(attr), arg.get(attr))
267
269 # Check that _pytype arg overrides original py:pytype of 270 # ObjectifiedDataElement 271 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 272 attrib={"gnu": "muh", "cat": "meeow", 273 "dog": "wuff"}, 274 bird="tchilp", dog="grrr") 275 value = objectify.DataElement(arg, _pytype="int") 276 self.assertTrue(isinstance(value, objectify.IntElement)) 277 self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 278 for attr in arg.attrib: 279 if not attr == objectify.PYTYPE_ATTRIBUTE: 280 self.assertEqual(value.get(attr), arg.get(attr))
281
283 # Check that _xsi arg overrides original xsi:type of given 284 # ObjectifiedDataElement 285 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 286 attrib={"gnu": "muh", "cat": "meeow", 287 "dog": "wuff"}, 288 bird="tchilp", dog="grrr") 289 value = objectify.DataElement(arg, _xsi="xsd:int") 290 self.assertTrue(isinstance(value, objectify.IntElement)) 291 self.assertEqual(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 292 self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 293 for attr in arg.attrib: 294 if not attr in [objectify.PYTYPE_ATTRIBUTE, 295 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 296 self.assertEqual(value.get(attr), arg.get(attr))
297
299 # Check that _pytype and _xsi args override original py:pytype and 300 # xsi:type attributes of given ObjectifiedDataElement 301 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 302 attrib={"gnu": "muh", "cat": "meeow", 303 "dog": "wuff"}, 304 bird="tchilp", dog="grrr") 305 value = objectify.DataElement(arg, _pytype="int", _xsi="xsd:int") 306 self.assertTrue(isinstance(value, objectify.IntElement)) 307 self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 308 self.assertEqual(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 309 for attr in arg.attrib: 310 if not attr in [objectify.PYTYPE_ATTRIBUTE, 311 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 312 self.assertEqual(value.get(attr), arg.get(attr))
313
315 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 316 _pytype="int")
317
319 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 320 _xsi="xsd:int")
321
323 arg = objectify.DataElement(3.1415) 324 self.assertRaises(ValueError, objectify.DataElement, arg, 325 _pytype="int")
326
328 arg = objectify.DataElement(3.1415) 329 self.assertRaises(ValueError, objectify.DataElement, arg, 330 _xsi="xsd:int")
331
333 arg = objectify.Element('arg') 334 value = objectify.DataElement(arg) 335 self.assertTrue(isinstance(value, objectify.ObjectifiedElement)) 336 for attr in arg.attrib: 337 self.assertEqual(value.get(attr), arg.get(attr))
338
339 - def test_root(self):
340 root = self.Element("test") 341 self.assertTrue(isinstance(root, objectify.ObjectifiedElement))
342
343 - def test_str(self):
344 root = self.Element("test") 345 self.assertEqual('', str(root))
346
347 - def test_child(self):
348 root = self.XML(xml_str) 349 self.assertEqual("0", root.c1.c2.text)
350
351 - def test_child_ns_nons(self):
352 root = self.XML(""" 353 <root> 354 <foo:x xmlns:foo="/foo/bar">1</foo:x> 355 <x>2</x> 356 </root> 357 """) 358 self.assertEqual(2, root.x)
359
360 - def test_countchildren(self):
361 root = self.XML(xml_str) 362 self.assertEqual(1, root.countchildren()) 363 self.assertEqual(5, root.c1.countchildren())
364
365 - def test_child_getattr(self):
366 root = self.XML(xml_str) 367 self.assertEqual("0", getattr(root.c1, "{objectified}c2").text) 368 self.assertEqual("3", getattr(root.c1, "{otherNS}c2").text)
369
370 - def test_child_nonexistant(self):
371 root = self.XML(xml_str) 372 self.assertRaises(AttributeError, getattr, root.c1, "NOT_THERE") 373 self.assertRaises(AttributeError, getattr, root.c1, "{unknownNS}c2")
374
376 root = self.XML(xml_str) 377 self.assertEqual("4", getattr(root.c1, "{}c2").text) 378 self.assertEqual("0", getattr(root.c1, "c2").text)
379
380 - def test_setattr(self):
381 for val in [ 382 2, 2**32, 1.2, "Won't get fooled again", 383 _str("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1'), True, 384 False, None]: 385 root = self.Element('root') 386 attrname = 'val' 387 setattr(root, attrname, val) 388 result = getattr(root, attrname) 389 self.assertEqual(val, result) 390 self.assertEqual(type(val), type(result.pyval))
391
392 - def test_setattr_nonunicode(self):
393 root = self.Element('root') 394 attrname = 'val' 395 val = _bytes("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1') 396 self.assertRaises(ValueError, setattr, root, attrname, val) 397 self.assertRaises(AttributeError, getattr, root, attrname)
398
399 - def test_addattr(self):
400 root = self.XML(xml_str) 401 self.assertEqual(1, len(root.c1)) 402 root.addattr("c1", "test") 403 self.assertEqual(2, len(root.c1)) 404 self.assertEqual("test", root.c1[1].text)
405
406 - def test_addattr_element(self):
407 root = self.XML(xml_str) 408 self.assertEqual(1, len(root.c1)) 409 410 new_el = self.Element("test", myattr="5") 411 root.addattr("c1", new_el) 412 self.assertEqual(2, len(root.c1)) 413 self.assertEqual(None, root.c1[0].get("myattr")) 414 self.assertEqual("5", root.c1[1].get("myattr"))
415
416 - def test_addattr_list(self):
417 root = self.XML(xml_str) 418 self.assertEqual(1, len(root.c1)) 419 420 new_el = self.Element("test") 421 self.etree.SubElement(new_el, "a", myattr="A") 422 self.etree.SubElement(new_el, "a", myattr="B") 423 424 root.addattr("c1", list(new_el.a)) 425 self.assertEqual(3, len(root.c1)) 426 self.assertEqual(None, root.c1[0].get("myattr")) 427 self.assertEqual("A", root.c1[1].get("myattr")) 428 self.assertEqual("B", root.c1[2].get("myattr"))
429
430 - def test_child_addattr(self):
431 root = self.XML(xml_str) 432 self.assertEqual(3, len(root.c1.c2)) 433 root.c1.addattr("c2", 3) 434 self.assertEqual(4, len(root.c1.c2)) 435 self.assertEqual("3", root.c1.c2[3].text)
436
437 - def test_child_index(self):
438 root = self.XML(xml_str) 439 self.assertEqual("0", root.c1.c2[0].text) 440 self.assertEqual("1", root.c1.c2[1].text) 441 self.assertEqual("2", root.c1.c2[2].text) 442 self.assertRaises(IndexError, operator.getitem, root.c1.c2, 3)
443
444 - def test_child_index_neg(self):
445 root = self.XML(xml_str) 446 self.assertEqual("0", root.c1.c2[0].text) 447 self.assertEqual("0", root.c1.c2[-3].text) 448 self.assertEqual("1", root.c1.c2[-2].text) 449 self.assertEqual("2", root.c1.c2[-1].text) 450 self.assertRaises(IndexError, operator.getitem, root.c1.c2, -4)
451
452 - def test_child_len(self):
453 root = self.XML(xml_str) 454 self.assertEqual(1, len(root)) 455 self.assertEqual(1, len(root.c1)) 456 self.assertEqual(3, len(root.c1.c2))
457
458 - def test_child_iter(self):
459 root = self.XML(xml_str) 460 self.assertEqual([root], 461 list(iter(root))) 462 self.assertEqual([root.c1], 463 list(iter(root.c1))) 464 self.assertEqual([root.c1.c2[0], root.c1.c2[1], root.c1.c2[2]], 465 list(iter((root.c1.c2))))
466
467 - def test_class_lookup(self):
468 root = self.XML(xml_str) 469 self.assertTrue(isinstance(root.c1.c2, objectify.ObjectifiedElement)) 470 self.assertFalse(isinstance(getattr(root.c1, "{otherNS}c2"), 471 objectify.ObjectifiedElement))
472
473 - def test_dir(self):
474 root = self.XML(xml_str) 475 dir_c1 = dir(objectify.ObjectifiedElement) + ['c1'] 476 dir_c1.sort() 477 dir_c2 = dir(objectify.ObjectifiedElement) + ['c2'] 478 dir_c2.sort() 479 480 self.assertEqual(dir_c1, dir(root)) 481 self.assertEqual(dir_c2, dir(root.c1))
482
483 - def test_vars(self):
484 root = self.XML(xml_str) 485 self.assertEqual({'c1' : root.c1}, vars(root)) 486 self.assertEqual({'c2' : root.c1.c2}, vars(root.c1))
487
488 - def test_child_set_ro(self):
489 root = self.XML(xml_str) 490 self.assertRaises(TypeError, setattr, root.c1.c2, 'text', "test") 491 self.assertRaises(TypeError, setattr, root.c1.c2, 'pyval', "test")
492 493 # slicing 494
495 - def test_getslice_complete(self):
496 root = self.XML("<root><c>c1</c><c>c2</c></root>") 497 self.assertEqual(["c1", "c2"], 498 [ c.text for c in root.c[:] ])
499
500 - def test_getslice_partial(self):
501 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 502 test_list = ["c1", "c2", "c3", "c4"] 503 504 self.assertEqual(test_list, 505 [ c.text for c in root.c[:] ]) 506 self.assertEqual(test_list[1:2], 507 [ c.text for c in root.c[1:2] ]) 508 self.assertEqual(test_list[-3:-1], 509 [ c.text for c in root.c[-3:-1] ]) 510 self.assertEqual(test_list[-3:3], 511 [ c.text for c in root.c[-3:3] ]) 512 self.assertEqual(test_list[-3000:3], 513 [ c.text for c in root.c[-3000:3] ]) 514 self.assertEqual(test_list[-3:3000], 515 [ c.text for c in root.c[-3:3000] ])
516
517 - def test_getslice_partial_neg(self):
518 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 519 test_list = ["c1", "c2", "c3", "c4"] 520 521 self.assertEqual(test_list, 522 [ c.text for c in root.c[:] ]) 523 self.assertEqual(test_list[2:1:-1], 524 [ c.text for c in root.c[2:1:-1] ]) 525 self.assertEqual(test_list[-1:-3:-1], 526 [ c.text for c in root.c[-1:-3:-1] ]) 527 self.assertEqual(test_list[2:-3:-1], 528 [ c.text for c in root.c[2:-3:-1] ]) 529 self.assertEqual(test_list[2:-3000:-1], 530 [ c.text for c in root.c[2:-3000:-1] ])
531 532 # slice assignment 533
534 - def test_setslice_complete(self):
535 Element = self.Element 536 root = Element("root") 537 root.c = ["c1", "c2"] 538 539 c1 = root.c[0] 540 c2 = root.c[1] 541 542 self.assertEqual([c1,c2], list(root.c)) 543 self.assertEqual(["c1", "c2"], 544 [ c.text for c in root.c ])
545
546 - def test_setslice_elements(self):
547 Element = self.Element 548 root = Element("root") 549 root.c = ["c1", "c2"] 550 551 c1 = root.c[0] 552 c2 = root.c[1] 553 554 self.assertEqual([c1,c2], list(root.c)) 555 self.assertEqual(["c1", "c2"], 556 [ c.text for c in root.c ]) 557 558 root2 = Element("root2") 559 root2.el = [ "test", "test" ] 560 self.assertEqual(["test", "test"], 561 [ el.text for el in root2.el ]) 562 563 root.c = [ root2.el, root2.el ] 564 self.assertEqual(["test", "test"], 565 [ c.text for c in root.c ]) 566 self.assertEqual(["test", "test"], 567 [ el.text for el in root2.el ]) 568 569 root.c[:] = [ c1, c2, c2, c1 ] 570 self.assertEqual(["c1", "c2", "c2", "c1"], 571 [ c.text for c in root.c ])
572
573 - def test_setslice_partial(self):
574 Element = self.Element 575 root = Element("root") 576 l = ["c1", "c2", "c3", "c4"] 577 root.c = l 578 579 self.assertEqual(["c1", "c2", "c3", "c4"], 580 [ c.text for c in root.c ]) 581 self.assertEqual(l, 582 [ c.text for c in root.c ]) 583 584 new_slice = ["cA", "cB"] 585 l[1:2] = new_slice 586 root.c[1:2] = new_slice 587 588 self.assertEqual(["c1", "cA", "cB", "c3", "c4"], l) 589 self.assertEqual(["c1", "cA", "cB", "c3", "c4"], 590 [ c.text for c in root.c ]) 591 self.assertEqual(l, 592 [ c.text for c in root.c ])
593
594 - def test_setslice_insert(self):
595 Element = self.Element 596 root = Element("root") 597 l = ["c1", "c2", "c3", "c4"] 598 root.c = l 599 600 self.assertEqual(["c1", "c2", "c3", "c4"], 601 [ c.text for c in root.c ]) 602 self.assertEqual(l, 603 [ c.text for c in root.c ]) 604 605 new_slice = ["cA", "cB"] 606 l[1:1] = new_slice 607 root.c[1:1] = new_slice 608 609 self.assertEqual(["c1", "cA", "cB", "c2", "c3", "c4"], l) 610 self.assertEqual(["c1", "cA", "cB", "c2", "c3", "c4"], 611 [ c.text for c in root.c ]) 612 self.assertEqual(l, 613 [ c.text for c in root.c ])
614
615 - def test_setslice_insert_neg(self):
616 Element = self.Element 617 root = Element("root") 618 l = ["c1", "c2", "c3", "c4"] 619 root.c = l 620 621 self.assertEqual(["c1", "c2", "c3", "c4"], 622 [ c.text for c in root.c ]) 623 self.assertEqual(l, 624 [ c.text for c in root.c ]) 625 626 new_slice = ["cA", "cB"] 627 l[-2:-2] = new_slice 628 root.c[-2:-2] = new_slice 629 630 self.assertEqual(["c1", "c2", "cA", "cB", "c3", "c4"], l) 631 self.assertEqual(["c1", "c2", "cA", "cB", "c3", "c4"], 632 [ c.text for c in root.c ]) 633 self.assertEqual(l, 634 [ c.text for c in root.c ])
635
636 - def test_setslice_empty(self):
637 Element = self.Element 638 root = Element("root") 639 640 root.c = [] 641 self.assertRaises( 642 AttributeError, getattr, root, 'c')
643
645 Element = self.Element 646 root = Element("root") 647 l = ["c1", "c2", "c3", "c4"] 648 root.c = l 649 650 self.assertEqual(["c1", "c2", "c3", "c4"], 651 [ c.text for c in root.c ]) 652 self.assertEqual(l, 653 [ c.text for c in root.c ]) 654 655 new_slice = ["cA", "cB", "cC"] 656 self.assertRaises( 657 ValueError, operator.setitem, 658 l, slice(1,2,-1), new_slice) 659 self.assertRaises( 660 ValueError, operator.setitem, 661 root.c, slice(1,2,-1), new_slice)
662
663 - def test_setslice_partial_neg(self):
664 Element = self.Element 665 root = Element("root") 666 l = ["c1", "c2", "c3", "c4"] 667 root.c = l 668 669 self.assertEqual(["c1", "c2", "c3", "c4"], 670 [ c.text for c in root.c ]) 671 self.assertEqual(l, 672 [ c.text for c in root.c ]) 673 674 new_slice = ["cA", "cB"] 675 l[-1:1:-1] = new_slice 676 root.c[-1:1:-1] = new_slice 677 678 self.assertEqual(["c1", "c2", "cB", "cA"], l) 679 self.assertEqual(["c1", "c2", "cB", "cA"], 680 [ c.text for c in root.c ]) 681 self.assertEqual(l, 682 [ c.text for c in root.c ])
683
685 Element = self.Element 686 root = Element("root") 687 l = ["c1", "c2", "c3", "c4"] 688 root.c = l 689 690 self.assertEqual(["c1", "c2", "c3", "c4"], 691 [ c.text for c in root.c ]) 692 self.assertEqual(l, 693 [ c.text for c in root.c ]) 694 695 new_slice = ["cA", "cB"] 696 l[-1:-4:-2] = new_slice 697 root.c[-1:-4:-2] = new_slice 698 699 self.assertEqual(["c1", "cB", "c3", "cA"], l) 700 self.assertEqual(["c1", "cB", "c3", "cA"], 701 [ c.text for c in root.c ]) 702 self.assertEqual(l, 703 [ c.text for c in root.c ])
704 705 # other stuff 706
707 - def test_set_string(self):
708 # make sure strings are not handled as sequences 709 Element = self.Element 710 root = Element("root") 711 root.c = "TEST" 712 self.assertEqual(["TEST"], 713 [ c.text for c in root.c ])
714
715 - def test_setitem_string(self):
716 # make sure strings are set as children 717 Element = self.Element 718 root = Element("root") 719 root["c"] = "TEST" 720 self.assertEqual(["TEST"], 721 [ c.text for c in root.c ])
722
724 # make sure 'text' etc. are set as children 725 Element = self.Element 726 root = Element("root") 727 728 root["text"] = "TEST" 729 self.assertEqual(["TEST"], 730 [ c.text for c in root["text"] ]) 731 732 root["tail"] = "TEST" 733 self.assertEqual(["TEST"], 734 [ c.text for c in root["tail"] ]) 735 736 root["pyval"] = "TEST" 737 self.assertEqual(["TEST"], 738 [ c.text for c in root["pyval"] ]) 739 740 root["tag"] = "TEST" 741 self.assertEqual(["TEST"], 742 [ c.text for c in root["tag"] ])
743
744 - def test_findall(self):
745 XML = self.XML 746 root = XML('<a><b><c/></b><b/><c><b/></c></a>') 747 self.assertEqual(1, len(root.findall("c"))) 748 self.assertEqual(2, len(root.findall(".//c"))) 749 self.assertEqual(3, len(root.findall(".//b"))) 750 self.assertTrue(root.findall(".//b")[1] is root.getchildren()[1])
751
752 - def test_findall_ns(self):
753 XML = self.XML 754 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>') 755 self.assertEqual(2, len(root.findall(".//{X}b"))) 756 self.assertEqual(3, len(root.findall(".//b"))) 757 self.assertEqual(2, len(root.findall("b")))
758
759 - def test_build_tree(self):
760 root = self.Element('root') 761 root.a = 5 762 root.b = 6 763 self.assertTrue(isinstance(root, objectify.ObjectifiedElement)) 764 self.assertTrue(isinstance(root.a, objectify.IntElement)) 765 self.assertTrue(isinstance(root.b, objectify.IntElement))
766
767 - def test_type_NoneType(self):
768 Element = self.Element 769 SubElement = self.etree.SubElement 770 771 nil_attr = XML_SCHEMA_NIL_ATTR 772 root = Element("{objectified}root") 773 SubElement(root, "{objectified}none") 774 SubElement(root, "{objectified}none", {nil_attr : "true"}) 775 self.assertFalse(isinstance(root.none, objectify.NoneElement)) 776 self.assertFalse(isinstance(root.none[0], objectify.NoneElement)) 777 self.assertTrue(isinstance(root.none[1], objectify.NoneElement)) 778 self.assertEqual(hash(root.none[1]), hash(None)) 779 self.assertEqual(root.none[1], None) 780 self.assertFalse(root.none[1])
781
782 - def test_data_element_NoneType(self):
783 value = objectify.DataElement(None) 784 self.assertTrue(isinstance(value, objectify.NoneElement)) 785 self.assertEqual(value, None) 786 self.assertEqual(value.get(XML_SCHEMA_NIL_ATTR), "true")
787
788 - def test_type_bool(self):
789 Element = self.Element 790 SubElement = self.etree.SubElement 791 root = Element("{objectified}root") 792 root.bool = True 793 self.assertEqual(root.bool, True) 794 self.assertEqual(root.bool + root.bool, True + True) 795 self.assertEqual(True + root.bool, True + root.bool) 796 self.assertEqual(root.bool * root.bool, True * True) 797 self.assertEqual(int(root.bool), int(True)) 798 self.assertEqual(hash(root.bool), hash(True)) 799 self.assertEqual(complex(root.bool), complex(True)) 800 self.assertTrue(isinstance(root.bool, objectify.BoolElement)) 801 802 root.bool = False 803 self.assertEqual(root.bool, False) 804 self.assertEqual(root.bool + root.bool, False + False) 805 self.assertEqual(False + root.bool, False + root.bool) 806 self.assertEqual(root.bool * root.bool, False * False) 807 self.assertEqual(int(root.bool), int(False)) 808 self.assertEqual(hash(root.bool), hash(False)) 809 self.assertEqual(complex(root.bool), complex(False)) 810 self.assertTrue(isinstance(root.bool, objectify.BoolElement))
811
812 - def test_data_element_bool(self):
813 value = objectify.DataElement(True) 814 self.assertTrue(isinstance(value, objectify.BoolElement)) 815 self.assertEqual(value, True) 816 817 value = objectify.DataElement(False) 818 self.assertTrue(isinstance(value, objectify.BoolElement)) 819 self.assertEqual(value, False)
820
821 - def test_type_str(self):
822 Element = self.Element 823 SubElement = self.etree.SubElement 824 root = Element("{objectified}root") 825 root.s = "test" 826 self.assertTrue(isinstance(root.s, objectify.StringElement))
827
828 - def test_type_str_intliteral(self):
829 Element = self.Element 830 SubElement = self.etree.SubElement 831 root = Element("{objectified}root") 832 root.s = "3" 833 self.assertTrue(isinstance(root.s, objectify.StringElement))
834
835 - def test_type_str_floatliteral(self):
836 Element = self.Element 837 SubElement = self.etree.SubElement 838 root = Element("{objectified}root") 839 root.s = "3.72" 840 self.assertTrue(isinstance(root.s, objectify.StringElement))
841
842 - def test_type_str_mul(self):
843 Element = self.Element 844 SubElement = self.etree.SubElement 845 root = Element("{objectified}root") 846 root.s = "test" 847 848 self.assertEqual("test" * 5, root.s * 5) 849 self.assertEqual(5 * "test", 5 * root.s) 850 851 self.assertRaises(TypeError, operator.mul, root.s, "honk") 852 self.assertRaises(TypeError, operator.mul, "honk", root.s)
853
854 - def test_type_str_add(self):
855 Element = self.Element 856 SubElement = self.etree.SubElement 857 root = Element("{objectified}root") 858 root.s = "test" 859 860 s = "toast" 861 self.assertEqual("test" + s, root.s + s) 862 self.assertEqual(s + "test", s + root.s)
863
864 - def test_type_str_mod(self):
865 s = "%d %f %s %r" 866 el = objectify.DataElement(s) 867 values = (1, 7.0, "abcd", None) 868 self.assertEqual(s % values, el % values) 869 870 s = "%d" 871 el = objectify.DataElement(s) 872 val = 5 873 self.assertEqual(s % val, el % val) 874 875 s = "%d %s" 876 el = objectify.DataElement(s) 877 val = 5 878 self.assertRaises(TypeError, el.__mod__, val) 879 880 s = "" 881 el = objectify.DataElement(s) 882 val = 5 883 self.assertRaises(TypeError, el.__mod__, val)
884
885 - def test_type_str_hash(self):
886 v = "1" 887 el = objectify.DataElement(v) 888 self.assertEqual(hash(el), hash("1"))
889
890 - def test_type_str_as_int(self):
891 v = "1" 892 el = objectify.DataElement(v) 893 self.assertEqual(int(el), 1)
894
895 - def test_type_str_as_float(self):
896 v = "1" 897 el = objectify.DataElement(v) 898 self.assertEqual(float(el), 1)
899
900 - def test_type_str_as_complex(self):
901 v = "1" 902 el = objectify.DataElement(v) 903 self.assertEqual(complex(el), 1)
904
906 s = "%d %f %s %r" 907 el = objectify.DataElement(s) 908 values = (objectify.DataElement(1), 909 objectify.DataElement(7.0), 910 objectify.DataElement("abcd"), 911 objectify.DataElement(None)) 912 self.assertEqual(s % values, el % values)
913
914 - def test_data_element_str(self):
915 value = objectify.DataElement("test") 916 self.assertTrue(isinstance(value, objectify.StringElement)) 917 self.assertEqual(value, "test")
918
920 value = objectify.DataElement("3") 921 self.assertTrue(isinstance(value, objectify.StringElement)) 922 self.assertEqual(value, "3")
923
925 value = objectify.DataElement("3.20") 926 self.assertTrue(isinstance(value, objectify.StringElement)) 927 self.assertEqual(value, "3.20")
928
929 - def test_type_ustr(self):
930 Element = self.Element 931 SubElement = self.etree.SubElement 932 root = Element("{objectified}root") 933 root.s = _str("test") 934 self.assertTrue(isinstance(root.s, objectify.StringElement))
935
936 - def test_type_ustr_intliteral(self):
937 Element = self.Element 938 SubElement = self.etree.SubElement 939 root = Element("{objectified}root") 940 root.s = _str("3") 941 self.assertTrue(isinstance(root.s, objectify.StringElement))
942
944 Element = self.Element 945 SubElement = self.etree.SubElement 946 root = Element("{objectified}root") 947 root.s = _str("3.72") 948 self.assertTrue(isinstance(root.s, objectify.StringElement))
949
950 - def test_type_ustr_mul(self):
951 Element = self.Element 952 SubElement = self.etree.SubElement 953 root = Element("{objectified}root") 954 root.s = _str("test") 955 956 self.assertEqual(_str("test") * 5, root.s * 5) 957 self.assertEqual(5 * _str("test"), 5 * root.s) 958 959 self.assertRaises(TypeError, operator.mul, root.s, _str("honk")) 960 self.assertRaises(TypeError, operator.mul, _str("honk"), root.s)
961
962 - def test_type_ustr_add(self):
963 Element = self.Element 964 SubElement = self.etree.SubElement 965 root = Element("{objectified}root") 966 root.s = _str("test") 967 968 s = _str("toast") 969 self.assertEqual(_str("test") + s, root.s + s) 970 self.assertEqual(s + _str("test"), s + root.s)
971
972 - def test_data_element_ustr(self):
973 value = objectify.DataElement(_str("test")) 974 self.assertTrue(isinstance(value, objectify.StringElement)) 975 self.assertEqual(value, _str("test"))
976
978 value = objectify.DataElement("3") 979 self.assertTrue(isinstance(value, objectify.StringElement)) 980 self.assertEqual(value, _str("3"))
981
983 value = objectify.DataElement(_str("3.20")) 984 self.assertTrue(isinstance(value, objectify.StringElement)) 985 self.assertEqual(value, _str("3.20"))
986
987 - def test_type_int(self):
988 Element = self.Element 989 SubElement = self.etree.SubElement 990 root = Element("{objectified}root") 991 root.none = 5 992 self.assertTrue(isinstance(root.none, objectify.IntElement))
993
994 - def test_data_element_int(self):
995 value = objectify.DataElement(5) 996 self.assertTrue(isinstance(value, objectify.IntElement)) 997 self.assertEqual(value, 5)
998
999 - def test_data_element_int_hash(self):
1000 value = objectify.DataElement(123) 1001 self.assertEqual(hash(value), hash(123))
1002
1003 - def test_type_float(self):
1004 Element = self.Element 1005 SubElement = self.etree.SubElement 1006 root = Element("{objectified}root") 1007 root.none = 5.5 1008 self.assertTrue(isinstance(root.none, objectify.FloatElement))
1009
1010 - def test_data_element_float(self):
1011 value = objectify.DataElement(5.5) 1012 self.assertTrue(isinstance(value, objectify.FloatElement)) 1013 self.assertEqual(value, 5.5)
1014
1016 value = objectify.DataElement(5.5) 1017 self.assertEqual(hash(value), hash(5.5))
1018
1019 - def test_type_float_precision(self):
1020 # test not losing precision by shortened float str() value 1021 # repr(2.305064300557): '2.305064300557' 1022 # str(2.305064300557): '2.30506430056' 1023 # "%57.54f" % 2.305064300557: 1024 # ' 2.305064300556999956626214043353684246540069580078125000' 1025 Element = self.Element 1026 root = Element("{objectified}root") 1027 s = "2.305064300557" 1028 root.f = float(s) 1029 self.assertTrue(isinstance(root.f, objectify.FloatElement)) 1030 self.assertEqual(root.f.text, s) 1031 self.assertEqual(root.f.pyval, float(s))
1032
1034 # test precision preservation for FloatElement instantiation 1035 s = "2.305064300557" 1036 self.assertEqual(objectify.FloatElement(s), float(s))
1037
1039 # test consistent FloatElement values for the different instantiation 1040 # possibilities 1041 Element = self.Element 1042 root = Element("{objectified}root") 1043 s = "2.305064300557" 1044 f = float(s) 1045 float_elem = objectify.FloatElement(s) 1046 float_data_elem = objectify.DataElement(f) 1047 root.float_child = float(f) 1048 self.assertTrue(f == float_elem == float_data_elem == root.float_child)
1049
1051 # test not losing precision by shortened float str() value 1052 f = 2305064300557.0 1053 value = objectify.DataElement(f) 1054 self.assertTrue(isinstance(value, objectify.FloatElement)) 1055 self.assertEqual(value, f)
1056
1058 # test not losing precision by shortened float str() value 1059 f = 2305064300557.0 1060 value = objectify.DataElement(f) 1061 self.assertEqual(hash(value), hash(f))
1062
1063 - def test_data_element_xsitypes(self):
1064 for xsi, objclass in xsitype2objclass.items(): 1065 # 1 is a valid value for all ObjectifiedDataElement classes 1066 pyval = 1 1067 value = objectify.DataElement(pyval, _xsi=xsi) 1068 self.assertTrue(isinstance(value, objclass), 1069 "DataElement(%s, _xsi='%s') returns %s, expected %s" 1070 % (pyval, xsi, type(value), objclass))
1071
1073 for xsi, objclass in xsitype2objclass.items(): 1074 # 1 is a valid value for all ObjectifiedDataElement classes 1075 pyval = 1 1076 value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi) 1077 self.assertTrue(isinstance(value, objclass), 1078 "DataElement(%s, _xsi='%s') returns %s, expected %s" 1079 % (pyval, xsi, type(value), objclass))
1080
1082 for xsi, objclass in xsitype2objclass.items(): 1083 # 1 is a valid value for all ObjectifiedDataElement classes 1084 self.assertRaises(ValueError, objectify.DataElement, 1, 1085 _xsi="foo:%s" % xsi)
1086
1087 - def test_data_element_pytypes(self):
1088 for pytype, objclass in pytype2objclass.items(): 1089 # 1 is a valid value for all ObjectifiedDataElement classes 1090 pyval = 1 1091 value = objectify.DataElement(pyval, _pytype=pytype) 1092 self.assertTrue(isinstance(value, objclass), 1093 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1094 % (pyval, pytype, type(value), objclass))
1095
1097 pyval = 1 1098 pytype = "NoneType" 1099 objclass = objectify.NoneElement 1100 value = objectify.DataElement(pyval, _pytype=pytype) 1101 self.assertTrue(isinstance(value, objclass), 1102 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1103 % (pyval, pytype, type(value), objclass)) 1104 self.assertEqual(value.text, None) 1105 self.assertEqual(value.pyval, None)
1106
1108 # pre-2.0 lxml called NoneElement "none" 1109 pyval = 1 1110 pytype = "none" 1111 objclass = objectify.NoneElement 1112 value = objectify.DataElement(pyval, _pytype=pytype) 1113 self.assertTrue(isinstance(value, objclass), 1114 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1115 % (pyval, pytype, type(value), objclass)) 1116 self.assertEqual(value.text, None) 1117 self.assertEqual(value.pyval, None)
1118
1119 - def test_type_unregistered(self):
1120 Element = self.Element 1121 SubElement = self.etree.SubElement 1122 class MyFloat(float): 1123 pass
1124 root = Element("{objectified}root") 1125 root.myfloat = MyFloat(5.5) 1126 self.assertTrue(isinstance(root.myfloat, objectify.FloatElement)) 1127 self.assertEqual(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None)
1128
1129 - def test_data_element_unregistered(self):
1130 class MyFloat(float): 1131 pass
1132 value = objectify.DataElement(MyFloat(5.5)) 1133 self.assertTrue(isinstance(value, objectify.FloatElement)) 1134 self.assertEqual(value, 5.5) 1135 self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), None) 1136
1137 - def test_schema_types(self):
1138 XML = self.XML 1139 root = XML('''\ 1140 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1141 <b xsi:type="boolean">true</b> 1142 <b xsi:type="boolean">false</b> 1143 <b xsi:type="boolean">1</b> 1144 <b xsi:type="boolean">0</b> 1145 1146 <f xsi:type="float">5</f> 1147 <f xsi:type="double">5</f> 1148 1149 <s xsi:type="string">5</s> 1150 <s xsi:type="normalizedString">5</s> 1151 <s xsi:type="token">5</s> 1152 <s xsi:type="language">5</s> 1153 <s xsi:type="Name">5</s> 1154 <s xsi:type="NCName">5</s> 1155 <s xsi:type="ID">5</s> 1156 <s xsi:type="IDREF">5</s> 1157 <s xsi:type="ENTITY">5</s> 1158 <s xsi:type="NMTOKEN">5</s> 1159 1160 <l xsi:type="integer">5</l> 1161 <l xsi:type="nonPositiveInteger">5</l> 1162 <l xsi:type="negativeInteger">5</l> 1163 <l xsi:type="long">5</l> 1164 <l xsi:type="nonNegativeInteger">5</l> 1165 <l xsi:type="unsignedLong">5</l> 1166 <l xsi:type="unsignedInt">5</l> 1167 <l xsi:type="positiveInteger">5</l> 1168 1169 <i xsi:type="int">5</i> 1170 <i xsi:type="short">5</i> 1171 <i xsi:type="byte">5</i> 1172 <i xsi:type="unsignedShort">5</i> 1173 <i xsi:type="unsignedByte">5</i> 1174 1175 <n xsi:nil="true"/> 1176 </root> 1177 ''') 1178 1179 for b in root.b: 1180 self.assertTrue(isinstance(b, objectify.BoolElement)) 1181 self.assertEqual(True, root.b[0]) 1182 self.assertEqual(False, root.b[1]) 1183 self.assertEqual(True, root.b[2]) 1184 self.assertEqual(False, root.b[3]) 1185 1186 for f in root.f: 1187 self.assertTrue(isinstance(f, objectify.FloatElement)) 1188 self.assertEqual(5, f) 1189 1190 for s in root.s: 1191 self.assertTrue(isinstance(s, objectify.StringElement)) 1192 self.assertEqual("5", s) 1193 1194 for i in root.i: 1195 self.assertTrue(isinstance(i, objectify.IntElement)) 1196 self.assertEqual(5, i) 1197 1198 for l in root.l: 1199 self.assertTrue(isinstance(l, objectify.IntElement)) 1200 self.assertEqual(5, i) 1201 1202 self.assertTrue(isinstance(root.n, objectify.NoneElement)) 1203 self.assertEqual(None, root.n)
1204
1205 - def test_schema_types_prefixed(self):
1206 XML = self.XML 1207 root = XML('''\ 1208 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1209 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1210 <b xsi:type="xsd:boolean">true</b> 1211 <b xsi:type="xsd:boolean">false</b> 1212 <b xsi:type="xsd:boolean">1</b> 1213 <b xsi:type="xsd:boolean">0</b> 1214 1215 <f xsi:type="xsd:float">5</f> 1216 <f xsi:type="xsd:double">5</f> 1217 1218 <s xsi:type="xsd:string">5</s> 1219 <s xsi:type="xsd:normalizedString">5</s> 1220 <s xsi:type="xsd:token">5</s> 1221 <s xsi:type="xsd:language">5</s> 1222 <s xsi:type="xsd:Name">5</s> 1223 <s xsi:type="xsd:NCName">5</s> 1224 <s xsi:type="xsd:ID">5</s> 1225 <s xsi:type="xsd:IDREF">5</s> 1226 <s xsi:type="xsd:ENTITY">5</s> 1227 <s xsi:type="xsd:NMTOKEN">5</s> 1228 1229 <l xsi:type="xsd:integer">5</l> 1230 <l xsi:type="xsd:nonPositiveInteger">5</l> 1231 <l xsi:type="xsd:negativeInteger">5</l> 1232 <l xsi:type="xsd:long">5</l> 1233 <l xsi:type="xsd:nonNegativeInteger">5</l> 1234 <l xsi:type="xsd:unsignedLong">5</l> 1235 <l xsi:type="xsd:unsignedInt">5</l> 1236 <l xsi:type="xsd:positiveInteger">5</l> 1237 1238 <i xsi:type="xsd:int">5</i> 1239 <i xsi:type="xsd:short">5</i> 1240 <i xsi:type="xsd:byte">5</i> 1241 <i xsi:type="xsd:unsignedShort">5</i> 1242 <i xsi:type="xsd:unsignedByte">5</i> 1243 1244 <n xsi:nil="true"/> 1245 </root> 1246 ''') 1247 1248 for b in root.b: 1249 self.assertTrue(isinstance(b, objectify.BoolElement)) 1250 self.assertEqual(True, root.b[0]) 1251 self.assertEqual(False, root.b[1]) 1252 self.assertEqual(True, root.b[2]) 1253 self.assertEqual(False, root.b[3]) 1254 1255 for f in root.f: 1256 self.assertTrue(isinstance(f, objectify.FloatElement)) 1257 self.assertEqual(5, f) 1258 1259 for s in root.s: 1260 self.assertTrue(isinstance(s, objectify.StringElement)) 1261 self.assertEqual("5", s) 1262 1263 for i in root.i: 1264 self.assertTrue(isinstance(i, objectify.IntElement)) 1265 self.assertEqual(5, i) 1266 1267 for l in root.l: 1268 self.assertTrue(isinstance(l, objectify.IntElement)) 1269 self.assertEqual(5, l) 1270 1271 self.assertTrue(isinstance(root.n, objectify.NoneElement)) 1272 self.assertEqual(None, root.n)
1273
1274 - def test_type_str_sequence(self):
1275 XML = self.XML 1276 root = XML(_bytes('<root><b>why</b><b>try</b></root>')) 1277 strs = [ str(s) for s in root.b ] 1278 self.assertEqual(["why", "try"], 1279 strs)
1280
1281 - def test_type_str_cmp(self):
1282 XML = self.XML 1283 root = XML(_bytes('<root><b>test</b><b>taste</b><b></b><b/></root>')) 1284 self.assertFalse(root.b[0] < root.b[1]) 1285 self.assertFalse(root.b[0] <= root.b[1]) 1286 self.assertFalse(root.b[0] == root.b[1]) 1287 1288 self.assertTrue(root.b[0] != root.b[1]) 1289 self.assertTrue(root.b[0] >= root.b[1]) 1290 self.assertTrue(root.b[0] > root.b[1]) 1291 1292 self.assertEqual(root.b[0], "test") 1293 self.assertEqual("test", root.b[0]) 1294 1295 self.assertEqual("", root.b[2]) 1296 self.assertEqual(root.b[2], "") 1297 self.assertEqual("", root.b[3]) 1298 self.assertEqual(root.b[3], "") 1299 self.assertEqual(root.b[2], root.b[3]) 1300 1301 root.b = "test" 1302 self.assertTrue(root.b) 1303 root.b = "" 1304 self.assertFalse(root.b) 1305 self.assertEqual(root.b, "") 1306 self.assertEqual("", root.b)
1307
1308 - def test_type_int_cmp(self):
1309 XML = self.XML 1310 root = XML(_bytes('<root><b>5</b><b>6</b></root>')) 1311 self.assertTrue(root.b[0] < root.b[1]) 1312 self.assertTrue(root.b[0] <= root.b[1]) 1313 self.assertTrue(root.b[0] != root.b[1]) 1314 1315 self.assertFalse(root.b[0] == root.b[1]) 1316 self.assertFalse(root.b[0] >= root.b[1]) 1317 self.assertFalse(root.b[0] > root.b[1]) 1318 1319 self.assertEqual(root.b[0], 5) 1320 self.assertEqual(5, root.b[0]) 1321 self.assertNotEqual(root.b[0], "5") 1322 1323 root.b = 5 1324 self.assertTrue(root.b) 1325 root.b = 0 1326 self.assertFalse(root.b)
1327 1328 # float + long share the NumberElement implementation with int 1329
1330 - def test_type_bool_cmp(self):
1331 XML = self.XML 1332 root = XML(_bytes('<root><b>false</b><b>true</b></root>')) 1333 self.assertTrue(root.b[0] < root.b[1]) 1334 self.assertTrue(root.b[0] <= root.b[1]) 1335 self.assertTrue(root.b[0] != root.b[1]) 1336 1337 self.assertFalse(root.b[0] == root.b[1]) 1338 self.assertFalse(root.b[0] >= root.b[1]) 1339 self.assertFalse(root.b[0] > root.b[1]) 1340 1341 self.assertFalse(root.b[0]) 1342 self.assertTrue(root.b[1]) 1343 1344 self.assertEqual(root.b[0], False) 1345 self.assertEqual(False, root.b[0]) 1346 self.assertTrue(root.b[0] < 5) 1347 self.assertTrue(5 > root.b[0]) 1348 1349 root.b = True 1350 self.assertTrue(root.b) 1351 root.b = False 1352 self.assertFalse(root.b)
1353
1354 - def test_type_none_cmp(self):
1355 XML = self.XML 1356 root = XML(_bytes(""" 1357 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1358 <b xsi:nil="true"></b><b xsi:nil="true"/> 1359 </root>""")) 1360 self.assertTrue(root.b[0] == root.b[1]) 1361 self.assertFalse(root.b[0]) 1362 self.assertEqual(root.b[0], None) 1363 self.assertEqual(None, root.b[0])
1364 1365 # doesn't work in Py3: 1366 1367 #for comparison in ["abc", 5, 7.3, True, [], ()]: 1368 # none = root.b[1] 1369 # self.assertTrue(none < comparison, "%s (%s) should be < %s" % 1370 # (none, type(none), comparison) ) 1371 # self.assertTrue(comparison > none, "%s should be > %s (%s)" % 1372 # (comparison, none, type(none)) ) 1373
1374 - def test_dataelement_xsi(self):
1375 el = objectify.DataElement(1, _xsi="string") 1376 self.assertEqual( 1377 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1378 'xsd:string')
1379
1380 - def test_dataelement_xsi_nsmap(self):
1381 el = objectify.DataElement(1, _xsi="string", 1382 nsmap={'schema': XML_SCHEMA_NS}) 1383 self.assertEqual( 1384 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1385 'schema:string')
1386
1387 - def test_dataelement_xsi_prefix_error(self):
1388 self.assertRaises(ValueError, objectify.DataElement, 1, 1389 _xsi="foo:string")
1390
1391 - def test_pytype_annotation(self):
1392 XML = self.XML 1393 root = XML(_bytes('''\ 1394 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1395 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1396 <b>5</b> 1397 <b>test</b> 1398 <c>1.1</c> 1399 <c>\uF8D2</c> 1400 <x>true</x> 1401 <n xsi:nil="true" /> 1402 <n></n> 1403 <b xsi:type="double">5</b> 1404 <b xsi:type="float">5</b> 1405 <s xsi:type="string">23</s> 1406 <s py:pytype="str">42</s> 1407 <f py:pytype="float">300</f> 1408 <l py:pytype="long">2</l> 1409 <t py:pytype="TREE"></t> 1410 </a> 1411 ''')) 1412 objectify.annotate(root) 1413 1414 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1415 for c in root.iterchildren() ] 1416 self.assertEqual("int", child_types[ 0]) 1417 self.assertEqual("str", child_types[ 1]) 1418 self.assertEqual("float", child_types[ 2]) 1419 self.assertEqual("str", child_types[ 3]) 1420 self.assertEqual("bool", child_types[ 4]) 1421 self.assertEqual("NoneType", child_types[ 5]) 1422 self.assertEqual(None, child_types[ 6]) 1423 self.assertEqual("float", child_types[ 7]) 1424 self.assertEqual("float", child_types[ 8]) 1425 self.assertEqual("str", child_types[ 9]) 1426 self.assertEqual("int", child_types[10]) 1427 self.assertEqual("int", child_types[11]) 1428 self.assertEqual("int", child_types[12]) 1429 self.assertEqual(None, child_types[13]) 1430 1431 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1432
1433 - def test_pytype_annotation_empty(self):
1434 XML = self.XML 1435 root = XML(_bytes('''\ 1436 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1437 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1438 <n></n> 1439 </a> 1440 ''')) 1441 objectify.annotate(root) 1442 1443 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1444 for c in root.iterchildren() ] 1445 self.assertEqual(None, child_types[0]) 1446 1447 objectify.annotate(root, empty_pytype="str") 1448 1449 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1450 for c in root.iterchildren() ] 1451 self.assertEqual("str", child_types[0])
1452
1453 - def test_pytype_annotation_use_old(self):
1454 XML = self.XML 1455 root = XML(_bytes('''\ 1456 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1457 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1458 <b>5</b> 1459 <b>test</b> 1460 <c>1.1</c> 1461 <c>\uF8D2</c> 1462 <x>true</x> 1463 <n xsi:nil="true" /> 1464 <n></n> 1465 <b xsi:type="double">5</b> 1466 <b xsi:type="float">5</b> 1467 <s xsi:type="string">23</s> 1468 <s py:pytype="str">42</s> 1469 <f py:pytype="float">300</f> 1470 <l py:pytype="long">2</l> 1471 <t py:pytype="TREE"></t> 1472 </a> 1473 ''')) 1474 objectify.annotate(root, ignore_old=False) 1475 1476 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1477 for c in root.iterchildren() ] 1478 self.assertEqual("int", child_types[ 0]) 1479 self.assertEqual("str", child_types[ 1]) 1480 self.assertEqual("float", child_types[ 2]) 1481 self.assertEqual("str", child_types[ 3]) 1482 self.assertEqual("bool", child_types[ 4]) 1483 self.assertEqual("NoneType", child_types[ 5]) 1484 self.assertEqual(None, child_types[ 6]) 1485 self.assertEqual("float", child_types[ 7]) 1486 self.assertEqual("float", child_types[ 8]) 1487 self.assertEqual("str", child_types[ 9]) 1488 self.assertEqual("str", child_types[10]) 1489 self.assertEqual("float", child_types[11]) 1490 self.assertEqual("int", child_types[12]) 1491 self.assertEqual(TREE_PYTYPE, child_types[13]) 1492 1493 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1494
1495 - def test_pytype_xsitype_annotation(self):
1496 XML = self.XML 1497 root = XML(_bytes('''\ 1498 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1499 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1500 <b>5</b> 1501 <b>test</b> 1502 <c>1.1</c> 1503 <c>\uF8D2</c> 1504 <x>true</x> 1505 <n xsi:nil="true" /> 1506 <n></n> 1507 <b xsi:type="double">5</b> 1508 <b xsi:type="float">5</b> 1509 <s xsi:type="string">23</s> 1510 <s py:pytype="str">42</s> 1511 <f py:pytype="float">300</f> 1512 <l py:pytype="long">2</l> 1513 <t py:pytype="TREE"></t> 1514 </a> 1515 ''')) 1516 objectify.annotate(root, ignore_old=False, ignore_xsi=False, 1517 annotate_xsi=1, annotate_pytype=1) 1518 1519 # check py annotations 1520 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1521 for c in root.iterchildren() ] 1522 self.assertEqual("int", child_types[ 0]) 1523 self.assertEqual("str", child_types[ 1]) 1524 self.assertEqual("float", child_types[ 2]) 1525 self.assertEqual("str", child_types[ 3]) 1526 self.assertEqual("bool", child_types[ 4]) 1527 self.assertEqual("NoneType", child_types[ 5]) 1528 self.assertEqual(None, child_types[ 6]) 1529 self.assertEqual("float", child_types[ 7]) 1530 self.assertEqual("float", child_types[ 8]) 1531 self.assertEqual("str", child_types[ 9]) 1532 self.assertEqual("str", child_types[10]) 1533 self.assertEqual("float", child_types[11]) 1534 self.assertEqual("int", child_types[12]) 1535 self.assertEqual(TREE_PYTYPE, child_types[13]) 1536 1537 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1538 1539 child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1540 for c in root.iterchildren() ] 1541 1542 # check xsi annotations 1543 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1544 for c in root.iterchildren() ] 1545 self.assertEqual("xsd:integer", child_types[ 0]) 1546 self.assertEqual("xsd:string", child_types[ 1]) 1547 self.assertEqual("xsd:double", child_types[ 2]) 1548 self.assertEqual("xsd:string", child_types[ 3]) 1549 self.assertEqual("xsd:boolean", child_types[ 4]) 1550 self.assertEqual(None, child_types[ 5]) 1551 self.assertEqual(None, child_types[ 6]) 1552 self.assertEqual("xsd:double", child_types[ 7]) 1553 self.assertEqual("xsd:float", child_types[ 8]) 1554 self.assertEqual("xsd:string", child_types[ 9]) 1555 self.assertEqual("xsd:string", child_types[10]) 1556 self.assertEqual("xsd:double", child_types[11]) 1557 self.assertEqual("xsd:integer", child_types[12]) 1558 self.assertEqual(None, child_types[13]) 1559 1560 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1561
1562 - def test_xsiannotate_use_old(self):
1563 XML = self.XML 1564 root = XML(_bytes('''\ 1565 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1566 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1567 <b>5</b> 1568 <b>test</b> 1569 <c>1.1</c> 1570 <c>\uF8D2</c> 1571 <x>true</x> 1572 <n xsi:nil="true" /> 1573 <n></n> 1574 <b xsi:type="double">5</b> 1575 <b xsi:type="float">5</b> 1576 <s xsi:type="string">23</s> 1577 <s py:pytype="str">42</s> 1578 <f py:pytype="float">300</f> 1579 <l py:pytype="long">2</l> 1580 <t py:pytype="TREE"></t> 1581 </a> 1582 ''')) 1583 objectify.xsiannotate(root, ignore_old=False) 1584 1585 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1586 for c in root.iterchildren() ] 1587 self.assertEqual("xsd:integer", child_types[ 0]) 1588 self.assertEqual("xsd:string", child_types[ 1]) 1589 self.assertEqual("xsd:double", child_types[ 2]) 1590 self.assertEqual("xsd:string", child_types[ 3]) 1591 self.assertEqual("xsd:boolean", child_types[ 4]) 1592 self.assertEqual(None, child_types[ 5]) 1593 self.assertEqual(None, child_types[ 6]) 1594 self.assertEqual("xsd:double", child_types[ 7]) 1595 self.assertEqual("xsd:float", child_types[ 8]) 1596 self.assertEqual("xsd:string", child_types[ 9]) 1597 self.assertEqual("xsd:string", child_types[10]) 1598 self.assertEqual("xsd:double", child_types[11]) 1599 self.assertEqual("xsd:integer", child_types[12]) 1600 self.assertEqual(None, child_types[13])
1601
1602 - def test_pyannotate_ignore_old(self):
1603 XML = self.XML 1604 root = XML(_bytes('''\ 1605 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1606 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1607 <b>5</b> 1608 <b>test</b> 1609 <c>1.1</c> 1610 <c>\uF8D2</c> 1611 <x>true</x> 1612 <n xsi:nil="true" /> 1613 <n></n> 1614 <b xsi:type="double">5</b> 1615 <b xsi:type="float">5</b> 1616 <s xsi:type="string">23</s> 1617 <s py:pytype="str">42</s> 1618 <f py:pytype="float">300</f> 1619 <l py:pytype="long">2</l> 1620 <t py:pytype="TREE"></t> 1621 </a> 1622 ''')) 1623 objectify.pyannotate(root, ignore_old=True) 1624 1625 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1626 for c in root.iterchildren() ] 1627 self.assertEqual("int", child_types[ 0]) 1628 self.assertEqual("str", child_types[ 1]) 1629 self.assertEqual("float", child_types[ 2]) 1630 self.assertEqual("str", child_types[ 3]) 1631 self.assertEqual("bool", child_types[ 4]) 1632 self.assertEqual("NoneType", child_types[ 5]) 1633 self.assertEqual(None, child_types[ 6]) 1634 self.assertEqual("float", child_types[ 7]) 1635 self.assertEqual("float", child_types[ 8]) 1636 self.assertEqual("str", child_types[ 9]) 1637 self.assertEqual("int", child_types[10]) 1638 self.assertEqual("int", child_types[11]) 1639 self.assertEqual("int", child_types[12]) 1640 self.assertEqual(None, child_types[13]) 1641 1642 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1643
1644 - def test_pyannotate_empty(self):
1645 XML = self.XML 1646 root = XML('''\ 1647 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1648 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1649 <n></n> 1650 </a> 1651 ''') 1652 objectify.pyannotate(root) 1653 1654 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1655 for c in root.iterchildren() ] 1656 self.assertEqual(None, child_types[0]) 1657 1658 objectify.annotate(root, empty_pytype="str") 1659 1660 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1661 for c in root.iterchildren() ] 1662 self.assertEqual("str", child_types[0])
1663
1664 - def test_pyannotate_use_old(self):
1665 XML = self.XML 1666 root = XML('''\ 1667 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1668 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1669 <b>5</b> 1670 <b>test</b> 1671 <c>1.1</c> 1672 <c>\uF8D2</c> 1673 <x>true</x> 1674 <n xsi:nil="true" /> 1675 <n></n> 1676 <b xsi:type="double">5</b> 1677 <b xsi:type="float">5</b> 1678 <s xsi:type="string">23</s> 1679 <s py:pytype="str">42</s> 1680 <f py:pytype="float">300</f> 1681 <l py:pytype="long">2</l> 1682 <t py:pytype="TREE"></t> 1683 </a> 1684 ''') 1685 objectify.pyannotate(root) 1686 1687 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1688 for c in root.iterchildren() ] 1689 self.assertEqual("int", child_types[ 0]) 1690 self.assertEqual("str", child_types[ 1]) 1691 self.assertEqual("float", child_types[ 2]) 1692 self.assertEqual("str", child_types[ 3]) 1693 self.assertEqual("bool", child_types[ 4]) 1694 self.assertEqual("NoneType", child_types[ 5]) 1695 self.assertEqual(None, child_types[ 6]) 1696 self.assertEqual("float", child_types[ 7]) 1697 self.assertEqual("float", child_types[ 8]) 1698 self.assertEqual("str", child_types[ 9]) 1699 self.assertEqual("str", child_types[10]) 1700 self.assertEqual("float", child_types[11]) 1701 self.assertEqual("int", child_types[12]) 1702 self.assertEqual(TREE_PYTYPE, child_types[13]) 1703 1704 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1705
1706 - def test_xsiannotate_ignore_old(self):
1707 XML = self.XML 1708 root = XML(_bytes('''\ 1709 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1710 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1711 <b>5</b> 1712 <b>test</b> 1713 <c>1.1</c> 1714 <c>\uF8D2</c> 1715 <x>true</x> 1716 <n xsi:nil="true" /> 1717 <n></n> 1718 <b xsi:type="double">5</b> 1719 <b xsi:type="float">5</b> 1720 <s xsi:type="string">23</s> 1721 <s py:pytype="str">42</s> 1722 <f py:pytype="float">300</f> 1723 <l py:pytype="long">2</l> 1724 <t py:pytype="TREE"></t> 1725 </a> 1726 ''')) 1727 objectify.xsiannotate(root, ignore_old=True) 1728 1729 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1730 for c in root.iterchildren() ] 1731 self.assertEqual("xsd:integer", child_types[ 0]) 1732 self.assertEqual("xsd:string", child_types[ 1]) 1733 self.assertEqual("xsd:double", child_types[ 2]) 1734 self.assertEqual("xsd:string", child_types[ 3]) 1735 self.assertEqual("xsd:boolean", child_types[ 4]) 1736 self.assertEqual(None, child_types[ 5]) 1737 self.assertEqual(None, child_types[ 6]) 1738 self.assertEqual("xsd:integer", child_types[ 7]) 1739 self.assertEqual("xsd:integer", child_types[ 8]) 1740 self.assertEqual("xsd:integer", child_types[ 9]) 1741 self.assertEqual("xsd:string", child_types[10]) 1742 self.assertEqual("xsd:double", child_types[11]) 1743 self.assertEqual("xsd:integer", child_types[12]) 1744 self.assertEqual(None, child_types[13]) 1745 1746 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1747
1748 - def test_deannotate(self):
1749 XML = self.XML 1750 root = XML(_bytes('''\ 1751 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1752 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1753 <b>5</b> 1754 <b>test</b> 1755 <c>1.1</c> 1756 <c>\uF8D2</c> 1757 <x>true</x> 1758 <n xsi:nil="true" /> 1759 <n></n> 1760 <b xsi:type="double">5</b> 1761 <b xsi:type="float">5</b> 1762 <s xsi:type="string">23</s> 1763 <s py:pytype="str">42</s> 1764 <f py:pytype="float">300</f> 1765 <l py:pytype="long">2</l> 1766 <t py:pytype="TREE"></t> 1767 </a> 1768 ''')) 1769 objectify.deannotate(root) 1770 1771 for c in root.getiterator(): 1772 self.assertEqual(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 1773 self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1774 1775 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1776
1777 - def test_xsinil_deannotate(self):
1778 XML = self.XML 1779 root = XML(_bytes('''\ 1780 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1781 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1782 <b>5</b> 1783 <b>test</b> 1784 <c>1.1</c> 1785 <c>\uF8D2</c> 1786 <x>true</x> 1787 <n xsi:nil="true" /> 1788 <n></n> 1789 <b xsi:type="double">5</b> 1790 <b xsi:type="float">5</b> 1791 <s xsi:type="string">23</s> 1792 <s py:pytype="str">42</s> 1793 <f py:pytype="float">300</f> 1794 <l py:pytype="long">2</l> 1795 <t py:pytype="TREE"></t> 1796 </a> 1797 ''')) 1798 objectify.annotate( 1799 root, ignore_old=False, ignore_xsi=False, annotate_xsi=True, 1800 empty_pytype='str', empty_type='string') 1801 objectify.deannotate(root, pytype=False, xsi=False, xsi_nil=True) 1802 1803 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1804 for c in root.iterchildren() ] 1805 self.assertEqual("xsd:integer", child_types[ 0]) 1806 self.assertEqual("xsd:string", child_types[ 1]) 1807 self.assertEqual("xsd:double", child_types[ 2]) 1808 self.assertEqual("xsd:string", child_types[ 3]) 1809 self.assertEqual("xsd:boolean", child_types[ 4]) 1810 self.assertEqual(None, child_types[ 5]) 1811 self.assertEqual("xsd:string", child_types[ 6]) 1812 self.assertEqual("xsd:double", child_types[ 7]) 1813 self.assertEqual("xsd:float", child_types[ 8]) 1814 self.assertEqual("xsd:string", child_types[ 9]) 1815 self.assertEqual("xsd:string", child_types[10]) 1816 self.assertEqual("xsd:double", child_types[11]) 1817 self.assertEqual("xsd:integer", child_types[12]) 1818 self.assertEqual(None, child_types[13]) 1819 1820 self.assertEqual(None, root.n.get(XML_SCHEMA_NIL_ATTR)) 1821 1822 for c in root.iterchildren(): 1823 self.assertNotEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1824 # these have no equivalent in xsi:type 1825 if (c.get(objectify.PYTYPE_ATTRIBUTE) not in [TREE_PYTYPE, 1826 "NoneType"]): 1827 self.assertNotEqual( 1828 None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))
1829
1830 - def test_xsitype_deannotate(self):
1831 XML = self.XML 1832 root = XML(_bytes('''\ 1833 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1834 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1835 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1836 <b>5</b> 1837 <b>test</b> 1838 <c>1.1</c> 1839 <c>\uF8D2</c> 1840 <x>true</x> 1841 <n xsi:nil="true" /> 1842 <n></n> 1843 <b xsi:type="xsd:double">5</b> 1844 <b xsi:type="xsd:float">5</b> 1845 <s xsi:type="xsd:string">23</s> 1846 <s py:pytype="str">42</s> 1847 <f py:pytype="float">300</f> 1848 <l py:pytype="long">2</l> 1849 <t py:pytype="TREE"></t> 1850 </a> 1851 ''')) 1852 objectify.annotate(root) 1853 objectify.deannotate(root, pytype=False) 1854 1855 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1856 for c in root.iterchildren() ] 1857 self.assertEqual("int", child_types[ 0]) 1858 self.assertEqual("str", child_types[ 1]) 1859 self.assertEqual("float", child_types[ 2]) 1860 self.assertEqual("str", child_types[ 3]) 1861 self.assertEqual("bool", child_types[ 4]) 1862 self.assertEqual("NoneType", child_types[ 5]) 1863 self.assertEqual(None, child_types[ 6]) 1864 self.assertEqual("float", child_types[ 7]) 1865 self.assertEqual("float", child_types[ 8]) 1866 self.assertEqual("str", child_types[ 9]) 1867 self.assertEqual("int", child_types[10]) 1868 self.assertEqual("int", child_types[11]) 1869 self.assertEqual("int", child_types[12]) 1870 self.assertEqual(None, child_types[13]) 1871 1872 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1873 1874 for c in root.getiterator(): 1875 self.assertEqual(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))
1876
1877 - def test_pytype_deannotate(self):
1878 XML = self.XML 1879 root = XML(_bytes('''\ 1880 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1881 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1882 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1883 <b xsi:type="xsd:int">5</b> 1884 <b xsi:type="xsd:string">test</b> 1885 <c xsi:type="xsd:float">1.1</c> 1886 <c xsi:type="xsd:string">\uF8D2</c> 1887 <x xsi:type="xsd:boolean">true</x> 1888 <n xsi:nil="true" /> 1889 <n></n> 1890 <b xsi:type="xsd:double">5</b> 1891 <b xsi:type="xsd:float">5</b> 1892 <s xsi:type="xsd:string">23</s> 1893 <s xsi:type="xsd:string">42</s> 1894 <f xsi:type="xsd:float">300</f> 1895 <l xsi:type="xsd:long">2</l> 1896 <t py:pytype="TREE"></t> 1897 </a> 1898 ''')) 1899 objectify.annotate(root) 1900 objectify.deannotate(root, xsi=False) 1901 1902 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1903 for c in root.iterchildren() ] 1904 self.assertEqual("xsd:int", child_types[ 0]) 1905 self.assertEqual("xsd:string", child_types[ 1]) 1906 self.assertEqual("xsd:float", child_types[ 2]) 1907 self.assertEqual("xsd:string", child_types[ 3]) 1908 self.assertEqual("xsd:boolean", child_types[ 4]) 1909 self.assertEqual(None, child_types[ 5]) 1910 self.assertEqual(None, child_types[ 6]) 1911 self.assertEqual("xsd:double", child_types[ 7]) 1912 self.assertEqual("xsd:float", child_types[ 8]) 1913 self.assertEqual("xsd:string", child_types[ 9]) 1914 self.assertEqual("xsd:string", child_types[10]) 1915 self.assertEqual("xsd:float", child_types[11]) 1916 self.assertEqual("xsd:long", child_types[12]) 1917 self.assertEqual(None, child_types[13]) 1918 1919 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1920 1921 for c in root.getiterator(): 1922 self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1923
1924 - def test_change_pytype_attribute(self):
1925 XML = self.XML 1926 1927 xml = _bytes('''\ 1928 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1929 <b>5</b> 1930 <b>test</b> 1931 <c>1.1</c> 1932 <c>\uF8D2</c> 1933 <x>true</x> 1934 <n xsi:nil="true" /> 1935 <n></n> 1936 <b xsi:type="double">5</b> 1937 </a> 1938 ''') 1939 1940 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1941 objectify.set_pytype_attribute_tag("{TEST}test") 1942 1943 root = XML(xml) 1944 objectify.annotate(root) 1945 1946 attribs = root.xpath("//@py:%s" % pytype_name, 1947 namespaces={"py" : pytype_ns}) 1948 self.assertEqual(0, len(attribs)) 1949 attribs = root.xpath("//@py:test", 1950 namespaces={"py" : "TEST"}) 1951 self.assertEqual(7, len(attribs)) 1952 1953 objectify.set_pytype_attribute_tag() 1954 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1955 1956 self.assertNotEqual("test", pytype_ns.lower()) 1957 self.assertNotEqual("test", pytype_name.lower()) 1958 1959 root = XML(xml) 1960 attribs = root.xpath("//@py:%s" % pytype_name, 1961 namespaces={"py" : pytype_ns}) 1962 self.assertEqual(0, len(attribs)) 1963 1964 objectify.annotate(root) 1965 attribs = root.xpath("//@py:%s" % pytype_name, 1966 namespaces={"py" : pytype_ns}) 1967 self.assertEqual(7, len(attribs))
1968
1969 - def test_registered_types(self):
1970 orig_types = objectify.getRegisteredTypes() 1971 orig_types[0].unregister() 1972 self.assertEqual(orig_types[1:], objectify.getRegisteredTypes()) 1973 1974 class NewType(objectify.ObjectifiedDataElement): 1975 pass
1976 1977 def checkMyType(s): 1978 return True 1979 1980 pytype = objectify.PyType("mytype", checkMyType, NewType) 1981 self.assertTrue(pytype not in objectify.getRegisteredTypes()) 1982 pytype.register() 1983 self.assertTrue(pytype in objectify.getRegisteredTypes()) 1984 pytype.unregister() 1985 self.assertTrue(pytype not in objectify.getRegisteredTypes()) 1986 1987 pytype.register(before = [objectify.getRegisteredTypes()[0].name]) 1988 self.assertEqual(pytype, objectify.getRegisteredTypes()[0]) 1989 pytype.unregister() 1990 1991 pytype.register(after = [objectify.getRegisteredTypes()[0].name]) 1992 self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0]) 1993 pytype.unregister() 1994 1995 self.assertRaises(ValueError, pytype.register, 1996 before = [objectify.getRegisteredTypes()[0].name], 1997 after = [objectify.getRegisteredTypes()[1].name]) 1998
1999 - def test_registered_type_stringify(self):
2000 from datetime import datetime 2001 def parse_date(value): 2002 if len(value) != 14: 2003 raise ValueError(value) 2004 Y = int(value[0:4]) 2005 M = int(value[4:6]) 2006 D = int(value[6:8]) 2007 h = int(value[8:10]) 2008 m = int(value[10:12]) 2009 s = int(value[12:14]) 2010 return datetime(Y, M, D, h, m, s)
2011 2012 def stringify_date(date): 2013 return date.strftime("%Y%m%d%H%M%S") 2014 2015 class DatetimeElement(objectify.ObjectifiedDataElement): 2016 def pyval(self): 2017 return parse_date(self.text) 2018 pyval = property(pyval) 2019 2020 datetime_type = objectify.PyType( 2021 "datetime", parse_date, DatetimeElement, stringify_date) 2022 datetime_type.xmlSchemaTypes = "dateTime" 2023 datetime_type.register() 2024 2025 NAMESPACE = "http://foo.net/xmlns" 2026 NAMESPACE_MAP = {'ns': NAMESPACE} 2027 2028 r = objectify.Element("{%s}root" % NAMESPACE, nsmap=NAMESPACE_MAP) 2029 time = datetime.now() 2030 r.date = time 2031 2032 self.assertTrue(isinstance(r.date, DatetimeElement)) 2033 self.assertTrue(isinstance(r.date.pyval, datetime)) 2034 2035 self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 2036 self.assertEqual(r.date.text, stringify_date(time)) 2037 2038 r.date = objectify.E.date(time) 2039 2040 self.assertTrue(isinstance(r.date, DatetimeElement)) 2041 self.assertTrue(isinstance(r.date.pyval, datetime)) 2042 2043 self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 2044 self.assertEqual(r.date.text, stringify_date(time)) 2045 2046 date = objectify.DataElement(time) 2047 2048 self.assertTrue(isinstance(date, DatetimeElement)) 2049 self.assertTrue(isinstance(date.pyval, datetime)) 2050 2051 self.assertEqual(date.pyval, parse_date(stringify_date(time))) 2052 self.assertEqual(date.text, stringify_date(time)) 2053
2054 - def test_object_path(self):
2055 root = self.XML(xml_str) 2056 path = objectify.ObjectPath( "root.c1.c2" ) 2057 self.assertEqual(root.c1.c2.text, path.find(root).text) 2058 self.assertEqual(root.c1.c2.text, path(root).text)
2059
2060 - def test_object_path_list(self):
2061 root = self.XML(xml_str) 2062 path = objectify.ObjectPath( ['root', 'c1', 'c2'] ) 2063 self.assertEqual(root.c1.c2.text, path.find(root).text) 2064 self.assertEqual(root.c1.c2.text, path(root).text)
2065
2066 - def test_object_path_fail(self):
2067 root = self.XML(xml_str) 2068 path = objectify.ObjectPath( "root.c1.c99" ) 2069 self.assertRaises(AttributeError, path, root)
2070
2071 - def test_object_path_default_absolute(self):
2072 root = self.XML(xml_str) 2073 path = objectify.ObjectPath( "root.c1.c99" ) 2074 self.assertEqual(None, path(root, None)) 2075 path = objectify.ObjectPath( "root.c99.c2" ) 2076 self.assertEqual(None, path(root, None)) 2077 path = objectify.ObjectPath( "notroot.c99.c2" ) 2078 self.assertEqual(None, path(root, None))
2079
2080 - def test_object_path_default_relative(self):
2081 root = self.XML(xml_str) 2082 path = objectify.ObjectPath( ".c1.c99" ) 2083 self.assertEqual(None, path(root, None)) 2084 path = objectify.ObjectPath( ".c99.c2" ) 2085 self.assertEqual(None, path(root, None))
2086
2087 - def test_object_path_syntax(self):
2088 root = self.XML(xml_str) 2089 path = objectify.ObjectPath("root . {objectified}c1. c2") 2090 self.assertEqual(root.c1.c2.text, path(root).text) 2091 2092 path = objectify.ObjectPath(" root.{objectified} c1.c2 [ 0 ] ") 2093 self.assertEqual(root.c1.c2.text, path(root).text)
2094
2095 - def test_object_path_fail_parse_empty(self):
2096 self.assertRaises(ValueError, objectify.ObjectPath, "")
2097
2098 - def test_object_path_fail_parse_empty_list(self):
2099 self.assertRaises(ValueError, objectify.Object