lxml.tests.test

55 """Test cases for lxml.objectify 56 """ 57 etree = etree 58

59 - def XML(self, xml):

60 return self.etree.XML(xml, self.parser)

61

62 - def setUp(self):

63 super(ObjectifyTestCase, self).setUp() 64 self.parser = self.etree.XMLParser(remove_blank_text=True) 65 lookup = etree.ElementNamespaceClassLookup( 66 objectify.ObjectifyElementClassLookup() ) 67 self.parser.setElementClassLookup(lookup) 68 69 self.Element = self.parser.makeelement 70 71 ns = self.etree.Namespace("otherNS") 72 ns[None] = self.etree.ElementBase

73

74 - def tearDown(self):

75 self.etree.Namespace("otherNS").clear() 76 objectify.setPytypeAttributeTag() 77 super(ObjectifyTestCase, self).tearDown()

78

79 - def test_element_nsmap_default(self):

80 elt = objectify.Element("test") 81 self.assertEquals(elt.nsmap, DEFAULT_NSMAP)

82

83 - def test_element_nsmap_empty(self):

84 nsmap = {} 85 elt = objectify.Element("test", nsmap=nsmap) 86 self.assertEquals(elt.nsmap.values(), [PYTYPE_NAMESPACE])

87

88 - def test_element_nsmap_custom_prefixes(self):

89 nsmap = {"mypy": PYTYPE_NAMESPACE, 90 "myxsi": XML_SCHEMA_INSTANCE_NS, 91 "myxsd": XML_SCHEMA_NS} 92 elt = objectify.Element("test", nsmap=nsmap) 93 self.assertEquals(elt.nsmap, nsmap)

94

95 - def test_element_nsmap_custom(self):

96 nsmap = {"my": "someNS", 97 "myother": "someOtherNS", 98 "myxsd": XML_SCHEMA_NS} 99 elt = objectify.Element("test", nsmap=nsmap) 100 self.assert_(PYTYPE_NAMESPACE in elt.nsmap.values()) 101 for prefix, ns in nsmap.items(): 102 self.assert_(prefix in elt.nsmap) 103 self.assertEquals(nsmap[prefix], elt.nsmap[prefix])

104

105 - def test_sub_element_nsmap_default(self):

106 root = objectify.Element("root") 107 root.sub = objectify.Element("test") 108 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)

109

110 - def test_sub_element_nsmap_empty(self):

111 root = objectify.Element("root") 112 nsmap = {} 113 root.sub = objectify.Element("test", nsmap=nsmap) 114 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)

115

116 - def test_sub_element_nsmap_custom_prefixes(self):

117 root = objectify.Element("root") 118 nsmap = {"mypy": PYTYPE_NAMESPACE, 119 "myxsi": XML_SCHEMA_INSTANCE_NS, 120 "myxsd": XML_SCHEMA_NS} 121 root.sub = objectify.Element("test", nsmap=nsmap) 122 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)

123

124 - def test_sub_element_nsmap_custom(self):

125 root = objectify.Element("root") 126 nsmap = {"my": "someNS", 127 "myother": "someOtherNS", 128 "myxsd": XML_SCHEMA_NS,} 129 root.sub = objectify.Element("test", nsmap=nsmap) 130 expected = nsmap.copy() 131 del expected["myxsd"] 132 expected.update(DEFAULT_NSMAP) 133 self.assertEquals(root.sub.nsmap, expected)

134

135 - def test_data_element_nsmap_default(self):

136 value = objectify.DataElement("test this") 137 self.assertEquals(value.nsmap, DEFAULT_NSMAP)

138

139 - def test_data_element_nsmap_empty(self):

140 nsmap = {} 141 value = objectify.DataElement("test this", nsmap=nsmap) 142 self.assertEquals(value.nsmap.values(), [PYTYPE_NAMESPACE])

143

144 - def test_data_element_nsmap_custom_prefixes(self):

145 nsmap = {"mypy": PYTYPE_NAMESPACE, 146 "myxsi": XML_SCHEMA_INSTANCE_NS, 147 "myxsd": XML_SCHEMA_NS} 148 value = objectify.DataElement("test this", nsmap=nsmap) 149 self.assertEquals(value.nsmap, nsmap)

150

151 - def test_data_element_nsmap_custom(self):

152 nsmap = {"my": "someNS", 153 "myother": "someOtherNS", 154 "myxsd": XML_SCHEMA_NS,} 155 value = objectify.DataElement("test", nsmap=nsmap) 156 self.assert_(PYTYPE_NAMESPACE in value.nsmap.values()) 157 for prefix, ns in nsmap.items(): 158 self.assert_(prefix in value.nsmap) 159 self.assertEquals(nsmap[prefix], value.nsmap[prefix])

160

161 - def test_sub_data_element_nsmap_default(self):

162 root = objectify.Element("root") 163 root.value = objectify.DataElement("test this") 164 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)

165

166 - def test_sub_data_element_nsmap_empty(self):

167 root = objectify.Element("root") 168 nsmap = {} 169 root.value = objectify.DataElement("test this", nsmap=nsmap) 170 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)

171

172 - def test_sub_data_element_nsmap_custom_prefixes(self):

173 root = objectify.Element("root") 174 nsmap = {"mypy": PYTYPE_NAMESPACE, 175 "myxsi": XML_SCHEMA_INSTANCE_NS, 176 "myxsd": XML_SCHEMA_NS} 177 root.value = objectify.DataElement("test this", nsmap=nsmap) 178 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)

179

180 - def test_sub_data_element_nsmap_custom(self):

181 root = objectify.Element("root") 182 nsmap = {"my": "someNS", 183 "myother": "someOtherNS", 184 "myxsd": XML_SCHEMA_NS} 185 root.value = objectify.DataElement("test", nsmap=nsmap) 186 expected = nsmap.copy() 187 del expected["myxsd"] 188 expected.update(DEFAULT_NSMAP) 189 self.assertEquals(root.value.nsmap, expected)

190

191 - def test_data_element_attrib_attributes_precedence(self):

192 # keyword arguments override attrib entries 193 value = objectify.DataElement(23, _pytype="str", _xsi="foobar", 194 attrib={"gnu": "muh", "cat": "meeow", 195 "dog": "wuff"}, 196 bird="tchilp", dog="grrr") 197 self.assertEquals(value.get("gnu"), "muh") 198 self.assertEquals(value.get("cat"), "meeow") 199 self.assertEquals(value.get("dog"), "grrr") 200 self.assertEquals(value.get("bird"), "tchilp")

201

202 - def test_data_element_data_element_arg(self):

203 # Check that DataElement preserves all attributes ObjectifiedDataElement 204 # arguments 205 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 206 attrib={"gnu": "muh", "cat": "meeow", 207 "dog": "wuff"}, 208 bird="tchilp", dog="grrr") 209 value = objectify.DataElement(arg) 210 self.assert_(isinstance(value, objectify.StringElement)) 211 for attr in arg.attrib: 212 self.assertEquals(value.get(attr), arg.get(attr))

213

214 - def test_data_element_data_element_arg_pytype(self):

215 # Check that _pytype arg overrides original py:pytype of 216 # ObjectifiedDataElement 217 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 218 attrib={"gnu": "muh", "cat": "meeow", 219 "dog": "wuff"}, 220 bird="tchilp", dog="grrr") 221 value = objectify.DataElement(arg, _pytype="int") 222 self.assert_(isinstance(value, objectify.IntElement)) 223 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 224 for attr in arg.attrib: 225 if not attr == objectify.PYTYPE_ATTRIBUTE: 226 self.assertEquals(value.get(attr), arg.get(attr))

227

228 - def test_data_element_data_element_arg_xsitype(self):

229 # Check that _xsi arg overrides original xsi:type of given 230 # ObjectifiedDataElement 231 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 232 attrib={"gnu": "muh", "cat": "meeow", 233 "dog": "wuff"}, 234 bird="tchilp", dog="grrr") 235 value = objectify.DataElement(arg, _xsi="xsd:int") 236 self.assert_(isinstance(value, objectify.IntElement)) 237 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 238 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 239 for attr in arg.attrib: 240 if not attr in [objectify.PYTYPE_ATTRIBUTE, 241 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 242 self.assertEquals(value.get(attr), arg.get(attr))

243

244 - def test_data_element_data_element_arg_pytype_xsitype(self):

245 # Check that _pytype and _xsi args override original py:pytype and 246 # xsi:type attributes of given ObjectifiedDataElement 247 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 248 attrib={"gnu": "muh", "cat": "meeow", 249 "dog": "wuff"}, 250 bird="tchilp", dog="grrr") 251 value = objectify.DataElement(arg, _pytype="int", _xsi="xsd:int") 252 self.assert_(isinstance(value, objectify.IntElement)) 253 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 254 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 255 for attr in arg.attrib: 256 if not attr in [objectify.PYTYPE_ATTRIBUTE, 257 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 258 self.assertEquals(value.get(attr), arg.get(attr))

259

260 - def test_data_element_invalid_pytype(self):

261 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 262 _pytype="int")

263

264 - def test_data_element_invalid_xsi(self):

265 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 266 _xsi="xsd:int")

267

268 - def test_data_element_data_element_arg_invalid_pytype(self):

269 arg = objectify.DataElement(3.1415) 270 self.assertRaises(ValueError, objectify.DataElement, arg, 271 _pytype="int")

272

273 - def test_data_element_data_element_arg_invalid_xsi(self):

274 arg = objectify.DataElement(3.1415) 275 self.assertRaises(ValueError, objectify.DataElement, arg, 276 _xsi="xsd:int")

277

278 - def test_root(self):

279 root = self.Element("test") 280 self.assert_(isinstance(root, objectify.ObjectifiedElement))

281

282 - def test_str(self):

283 root = self.Element("test") 284 self.assertEquals('', str(root))

285

286 - def test_child(self):

287 root = self.XML(xml_str) 288 self.assertEquals("0", root.c1.c2.text)

289

290 - def test_countchildren(self):

291 root = self.XML(xml_str) 292 self.assertEquals(1, root.countchildren()) 293 self.assertEquals(5, root.c1.countchildren())

294

295 - def test_child_getattr(self):

296 root = self.XML(xml_str) 297 self.assertEquals("0", getattr(root.c1, "{objectified}c2").text) 298 self.assertEquals("3", getattr(root.c1, "{otherNS}c2").text)

299

300 - def test_child_nonexistant(self):

301 root = self.XML(xml_str) 302 self.assertRaises(AttributeError, getattr, root.c1, "NOT_THERE") 303 self.assertRaises(AttributeError, getattr, root.c1, "{unknownNS}c2")

304

305 - def test_addattr(self):

306 root = self.XML(xml_str) 307 self.assertEquals(1, len(root.c1)) 308 root.addattr("c1", "test") 309 self.assertEquals(2, len(root.c1)) 310 self.assertEquals("test", root.c1[1].text)

311

312 - def test_addattr_element(self):

313 root = self.XML(xml_str) 314 self.assertEquals(1, len(root.c1)) 315 316 new_el = self.Element("test", myattr="5") 317 root.addattr("c1", new_el) 318 self.assertEquals(2, len(root.c1)) 319 self.assertEquals(None, root.c1[0].get("myattr")) 320 self.assertEquals("5", root.c1[1].get("myattr"))

321

322 - def test_addattr_list(self):

323 root = self.XML(xml_str) 324 self.assertEquals(1, len(root.c1)) 325 326 new_el = self.Element("test") 327 self.etree.SubElement(new_el, "a", myattr="A") 328 self.etree.SubElement(new_el, "a", myattr="B") 329 330 root.addattr("c1", list(new_el.a)) 331 self.assertEquals(3, len(root.c1)) 332 self.assertEquals(None, root.c1[0].get("myattr")) 333 self.assertEquals("A", root.c1[1].get("myattr")) 334 self.assertEquals("B", root.c1[2].get("myattr"))

335

336 - def test_child_addattr(self):

337 root = self.XML(xml_str) 338 self.assertEquals(3, len(root.c1.c2)) 339 root.c1.addattr("c2", 3) 340 self.assertEquals(4, len(root.c1.c2)) 341 self.assertEquals("3", root.c1.c2[3].text)

342

343 - def test_child_index(self):

344 root = self.XML(xml_str) 345 self.assertEquals("0", root.c1.c2[0].text) 346 self.assertEquals("1", root.c1.c2[1].text) 347 self.assertEquals("2", root.c1.c2[2].text) 348 self.assertRaises(IndexError, itemgetter(3), root.c1.c2)

349

350 - def test_child_index_neg(self):

351 root = self.XML(xml_str) 352 self.assertEquals("0", root.c1.c2[0].text) 353 self.assertEquals("0", root.c1.c2[-3].text) 354 self.assertEquals("1", root.c1.c2[-2].text) 355 self.assertEquals("2", root.c1.c2[-1].text) 356 self.assertRaises(IndexError, itemgetter(-4), root.c1.c2)

357

358 - def test_child_len(self):

359 root = self.XML(xml_str) 360 self.assertEquals(1, len(root)) 361 self.assertEquals(1, len(root.c1)) 362 self.assertEquals(3, len(root.c1.c2))

363

364 - def test_child_iter(self):

365 root = self.XML(xml_str) 366 self.assertEquals([root], 367 list(iter(root))) 368 self.assertEquals([root.c1], 369 list(iter(root.c1))) 370 self.assertEquals([root.c1.c2[0], root.c1.c2[1], root.c1.c2[2]], 371 list(iter((root.c1.c2))))

372

373 - def test_class_lookup(self):

374 root = self.XML(xml_str) 375 self.assert_(isinstance(root.c1.c2, objectify.ObjectifiedElement)) 376 self.assertFalse(isinstance(getattr(root.c1, "{otherNS}c2"), 377 objectify.ObjectifiedElement))

378

379 - def test_dir(self):

380 root = self.XML(xml_str) 381 dir_c1 = dir(objectify.ObjectifiedElement) + ['c1'] 382 dir_c1.sort() 383 dir_c2 = dir(objectify.ObjectifiedElement) + ['c2'] 384 dir_c2.sort() 385 386 self.assertEquals(dir_c1, dir(root)) 387 self.assertEquals(dir_c2, dir(root.c1))

388

389 - def test_vars(self):

390 root = self.XML(xml_str) 391 self.assertEquals({'c1' : root.c1}, vars(root)) 392 self.assertEquals({'c2' : root.c1.c2}, vars(root.c1))

393

394 - def test_child_set_ro(self):

395 root = self.XML(xml_str) 396 self.assertRaises(TypeError, setattr, root.c1.c2, 'text', "test") 397 self.assertRaises(TypeError, setattr, root.c1.c2, 'pyval', "test")

398

399 - def test_setslice(self):

400 Element = self.Element 401 SubElement = self.etree.SubElement 402 root = Element("root") 403 root.c = ["c1", "c2"] 404 405 c1 = root.c[0] 406 c2 = root.c[1] 407 408 self.assertEquals([c1,c2], list(root.c)) 409 self.assertEquals(["c1", "c2"], 410 [ c.text for c in root.c ]) 411 412 root2 = Element("root2") 413 root2.el = [ "test", "test" ] 414 self.assertEquals(["test", "test"], 415 [ el.text for el in root2.el ]) 416 417 root.c = [ root2.el, root2.el ] 418 self.assertEquals(["test", "test"], 419 [ c.text for c in root.c ]) 420 self.assertEquals(["test", "test"], 421 [ el.text for el in root2.el ]) 422 423 root.c[:] = [ c1, c2, c2, c1 ] 424 self.assertEquals(["c1", "c2", "c2", "c1"], 425 [ c.text for c in root.c ])

426

427 - def test_set_string(self):

428 # make sure strings are not handled as sequences 429 Element = self.Element 430 SubElement = self.etree.SubElement 431 root = Element("root") 432 root.c = "TEST" 433 self.assertEquals(["TEST"], 434 [ c.text for c in root.c ])

435

436 - def test_setitem_string(self):

437 # make sure strings are set as children 438 Element = self.Element 439 SubElement = self.etree.SubElement 440 root = Element("root") 441 root["c"] = "TEST" 442 self.assertEquals(["TEST"], 443 [ c.text for c in root.c ])

444

445 - def test_setitem_string_special(self):

446 # make sure 'text' etc. are set as children 447 Element = self.Element 448 SubElement = self.etree.SubElement 449 root = Element("root") 450 451 root["text"] = "TEST" 452 self.assertEquals(["TEST"], 453 [ c.text for c in root["text"] ]) 454 455 root["tail"] = "TEST" 456 self.assertEquals(["TEST"], 457 [ c.text for c in root["tail"] ]) 458 459 root["pyval"] = "TEST" 460 self.assertEquals(["TEST"], 461 [ c.text for c in root["pyval"] ]) 462 463 root["tag"] = "TEST" 464 self.assertEquals(["TEST"], 465 [ c.text for c in root["tag"] ])

466

467 - def test_findall(self):

468 XML = self.XML 469 root = XML('<a><c/><c></c></a>') 470 self.assertEquals(1, len(root.findall("c"))) 471 self.assertEquals(2, len(root.findall(".//c"))) 472 self.assertEquals(3, len(root.findall(".//b"))) 473 self.assert_(root.findall(".//b")[1] is root.getchildren()[1])

474

475 - def test_findall_ns(self):

476 XML = self.XML 477 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>') 478 self.assertEquals(2, len(root.findall(".//{X}b"))) 479 self.assertEquals(3, len(root.findall(".//b"))) 480 self.assertEquals(2, len(root.findall("b")))

481

482 - def test_build_tree(self):

483 root = self.Element('root') 484 root.a = 5 485 root.b = 6 486 self.assert_(isinstance(root, objectify.ObjectifiedElement)) 487 self.assert_(isinstance(root.a, objectify.IntElement)) 488 self.assert_(isinstance(root.b, objectify.IntElement))

489

490 - def test_type_none(self):

491 Element = self.Element 492 SubElement = self.etree.SubElement 493 494 nil_attr = XML_SCHEMA_NIL_ATTR 495 root = Element("{objectified}root") 496 SubElement(root, "{objectified}none") 497 SubElement(root, "{objectified}none", {nil_attr : "true"}) 498 self.assertFalse(isinstance(root.none, objectify.NoneElement)) 499 self.assertFalse(isinstance(root.none[0], objectify.NoneElement)) 500 self.assert_(isinstance(root.none[1], objectify.NoneElement)) 501 self.assertEquals(root.none[1], None) 502 self.assertFalse(root.none[1])

503

504 - def test_data_element_none(self):

505 value = objectify.DataElement(None) 506 self.assert_(isinstance(value, objectify.NoneElement)) 507 self.assertEquals(value, None) 508 self.assertEquals(value.get(XML_SCHEMA_NIL_ATTR), "true")

509

510 - def test_type_bool(self):

511 Element = self.Element 512 SubElement = self.etree.SubElement 513 root = Element("{objectified}root") 514 root.bool = 'true' 515 self.assert_(isinstance(root.bool, objectify.BoolElement)) 516 self.assertEquals(root.bool, True) 517 518 root.bool = 'false' 519 self.assert_(isinstance(root.bool, objectify.BoolElement)) 520 self.assertEquals(root.bool, False)

521

522 - def test_data_element_bool(self):

523 value = objectify.DataElement(True) 524 self.assert_(isinstance(value, objectify.BoolElement)) 525 self.assertEquals(value, True) 526 527 value = objectify.DataElement(False) 528 self.assert_(isinstance(value, objectify.BoolElement)) 529 self.assertEquals(value, False)

530

531 - def test_type_str(self):

532 Element = self.Element 533 SubElement = self.etree.SubElement 534 root = Element("{objectified}root") 535 root.none = "test" 536 self.assert_(isinstance(root.none, objectify.StringElement))

537

538 - def test_type_str_mul(self):

539 Element = self.Element 540 SubElement = self.etree.SubElement 541 root = Element("{objectified}root") 542 root.none = "test" 543 544 self.assertEquals("test" * 5, root.none * 5) 545 self.assertEquals(5 * "test", 5 * root.none) 546 547 self.assertRaises(TypeError, operator.mul, root.none, "honk") 548 self.assertRaises(TypeError, operator.mul, "honk", root.none)

549

550 - def test_type_str_add(self):

551 Element = self.Element 552 SubElement = self.etree.SubElement 553 root = Element("{objectified}root") 554 root.none = "test" 555 556 s = "toast" 557 self.assertEquals("test" + s, root.none + s) 558 self.assertEquals(s + "test", s + root.none)

559

560 - def test_data_element_str(self):

561 value = objectify.DataElement("test") 562 self.assert_(isinstance(value, objectify.StringElement)) 563 self.assertEquals(value, "test")

564

565 - def test_type_int(self):

566 Element = self.Element 567 SubElement = self.etree.SubElement 568 root = Element("{objectified}root") 569 root.none = 5 570 self.assert_(isinstance(root.none, objectify.IntElement))

571

572 - def test_data_element_int(self):

573 value = objectify.DataElement(5) 574 self.assert_(isinstance(value, objectify.IntElement)) 575 self.assertEquals(value, 5)

576

577 - def test_type_float(self):

578 Element = self.Element 579 SubElement = self.etree.SubElement 580 root = Element("{objectified}root") 581 root.none = 5.5 582 self.assert_(isinstance(root.none, objectify.FloatElement))

583

584 - def test_data_element_float(self):

585 value = objectify.DataElement(5.5) 586 self.assert_(isinstance(value, objectify.FloatElement)) 587 self.assertEquals(value, 5.5)

588

589 - def test_data_element_xsitypes(self):

590 for xsi, objclass in xsitype2objclass.iteritems(): 591 # 1 is a valid value for all ObjectifiedDataElement classes 592 value = objectify.DataElement(1, _xsi=xsi) 593 self.assert_(isinstance(value, objclass))

594

595 - def test_data_element_xsitypes_xsdprefixed(self):

596 for xsi, objclass in xsitype2objclass.iteritems(): 597 # 1 is a valid value for all ObjectifiedDataElement classes 598 value = objectify.DataElement(1, _xsi="xsd:%s" % xsi) 599 self.assert_(isinstance(value, objclass))

600

601 - def test_data_element_xsitypes_prefixed(self):

602 for xsi, objclass in xsitype2objclass.iteritems(): 603 # 1 is a valid value for all ObjectifiedDataElement classes 604 self.assertRaises(ValueError, objectify.DataElement, 1, 605 _xsi="foo:%s" % xsi)

606

607 - def test_schema_types(self):

608 XML = self.XML 609 root = XML('''\ 610 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 611 true 612 false 613 1 614 0 615 616 <f xsi:type="float">5</f> 617 <f xsi:type="double">5</f> 618 619 <s xsi:type="string">5</s> 620 <s xsi:type="normalizedString">5</s> 621 <s xsi:type="token">5</s> 622 <s xsi:type="language">5</s> 623 <s xsi:type="Name">5</s> 624 <s xsi:type="NCName">5</s> 625 <s xsi:type="ID">5</s> 626 <s xsi:type="IDREF">5</s> 627 <s xsi:type="ENTITY">5</s> 628 <s xsi:type="NMTOKEN">5</s> 629 630 <l xsi:type="integer">5</l> 631 <l xsi:type="nonPositiveInteger">5</l> 632 <l xsi:type="negativeInteger">5</l> 633 <l xsi:type="long">5</l> 634 <l xsi:type="nonNegativeInteger">5</l> 635 <l xsi:type="unsignedLong">5</l> 636 <l xsi:type="unsignedInt">5</l> 637 <l xsi:type="positiveInteger">5</l> 638 639 5 640 5 641 5 642 5 643 5 644 645 <n xsi:nil="true"/> 646 </root> 647 ''') 648 649 for b in root.b: 650 self.assert_(isinstance(b, objectify.BoolElement)) 651 self.assertEquals(True, root.b[0]) 652 self.assertEquals(False, root.b[1]) 653 self.assertEquals(True, root.b[2]) 654 self.assertEquals(False, root.b[3]) 655 656 for f in root.f: 657 self.assert_(isinstance(f, objectify.FloatElement)) 658 self.assertEquals(5, f) 659 660 for s in root.s: 661 self.assert_(isinstance(s, objectify.StringElement)) 662 self.assertEquals("5", s) 663 664 for l in root.l: 665 self.assert_(isinstance(l, objectify.LongElement)) 666 self.assertEquals(5L, l) 667 668 for i in root.i: 669 self.assert_(isinstance(i, objectify.IntElement)) 670 self.assertEquals(5, i) 671 672 self.assert_(isinstance(root.n, objectify.NoneElement)) 673 self.assertEquals(None, root.n)

674

675 - def test_schema_types_prefixed(self):

676 XML = self.XML 677 root = XML('''\ 678 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 679 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 680 true 681 false 682 1 683 0 684 685 <f xsi:type="xsd:float">5</f> 686 <f xsi:type="xsd:double">5</f> 687 688 <s xsi:type="xsd:string">5</s> 689 <s xsi:type="xsd:normalizedString">5</s> 690 <s xsi:type="xsd:token">5</s> 691 <s xsi:type="xsd:language">5</s> 692 <s xsi:type="xsd:Name">5</s> 693 <s xsi:type="xsd:NCName">5</s> 694 <s xsi:type="xsd:ID">5</s> 695 <s xsi:type="xsd:IDREF">5</s> 696 <s xsi:type="xsd:ENTITY">5</s> 697 <s xsi:type="xsd:NMTOKEN">5</s> 698 699 <l xsi:type="xsd:integer">5</l> 700 <l xsi:type="xsd:nonPositiveInteger">5</l> 701 <l xsi:type="xsd:negativeInteger">5</l> 702 <l xsi:type="xsd:long">5</l> 703 <l xsi:type="xsd:nonNegativeInteger">5</l> 704 <l xsi:type="xsd:unsignedLong">5</l> 705 <l xsi:type="xsd:unsignedInt">5</l> 706 <l xsi:type="xsd:positiveInteger">5</l> 707 708 5 709 5 710 5 711 5 712 5 713 714 <n xsi:nil="true"/> 715 </root> 716 ''') 717 718 for b in root.b: 719 self.assert_(isinstance(b, objectify.BoolElement)) 720 self.assertEquals(True, root.b[0]) 721 self.assertEquals(False, root.b[1]) 722 self.assertEquals(True, root.b[2]) 723 self.assertEquals(False, root.b[3]) 724 725 for f in root.f: 726 self.assert_(isinstance(f, objectify.FloatElement)) 727 self.assertEquals(5, f) 728 729 for s in root.s: 730 self.assert_(isinstance(s, objectify.StringElement)) 731 self.assertEquals("5", s) 732 733 for l in root.l: 734 self.assert_(isinstance(l, objectify.LongElement)) 735 self.assertEquals(5L, l) 736 737 for i in root.i: 738 self.assert_(isinstance(i, objectify.IntElement)) 739 self.assertEquals(5, i) 740 741 self.assert_(isinstance(root.n, objectify.NoneElement)) 742 self.assertEquals(None, root.n)

743

744 - def test_type_str_sequence(self):

745 XML = self.XML 746 root = XML(u'<root>whytry</root>') 747 strs = [ str(s) for s in root.b ] 748 self.assertEquals(["why", "try"], 749 strs)

750

751 - def test_type_str_cmp(self):

752 XML = self.XML 753 root = XML(u'<root>testtaste</root>') 754 self.assertFalse(root.b[0] < root.b[1]) 755 self.assertFalse(root.b[0] <= root.b[1]) 756 self.assertFalse(root.b[0] == root.b[1]) 757 758 self.assert_(root.b[0] != root.b[1]) 759 self.assert_(root.b[0] >= root.b[1]) 760 self.assert_(root.b[0] > root.b[1]) 761 762 self.assertEquals(root.b[0], "test") 763 self.assertEquals("test", root.b[0]) 764 self.assert_(root.b[0] > 5) 765 self.assert_(5 < root.b[0]) 766 767 self.assertEquals("", root.b[2]) 768 self.assertEquals(root.b[2], "") 769 self.assertEquals("", root.b[3]) 770 self.assertEquals(root.b[3], "") 771 self.assertEquals(root.b[2], root.b[3]) 772 773 root.b = "test" 774 self.assert_(root.b) 775 root.b = "" 776 self.assertFalse(root.b) 777 self.assertEquals(root.b, "") 778 self.assertEquals("", root.b)

779

780 - def test_type_int_cmp(self):

781 XML = self.XML 782 root = XML(u'<root>56</root>') 783 self.assert_(root.b[0] < root.b[1]) 784 self.assert_(root.b[0] <= root.b[1]) 785 self.assert_(root.b[0] != root.b[1]) 786 787 self.assertFalse(root.b[0] == root.b[1]) 788 self.assertFalse(root.b[0] >= root.b[1]) 789 self.assertFalse(root.b[0] > root.b[1]) 790 791 self.assertEquals(root.b[0], 5) 792 self.assertEquals(5, root.b[0]) 793 self.assert_(root.b[0] < "5") 794 self.assert_("5" > root.b[0]) 795 796 root.b = 5 797 self.assert_(root.b) 798 root.b = 0 799 self.assertFalse(root.b)

800 801 # float + long share the NumberElement implementation with int 802

803 - def test_type_bool_cmp(self):

804 XML = self.XML 805 root = XML(u'<root>falsetrue</root>') 806 self.assert_(root.b[0] < root.b[1]) 807 self.assert_(root.b[0] <= root.b[1]) 808 self.assert_(root.b[0] != root.b[1]) 809 810 self.assertFalse(root.b[0] == root.b[1]) 811 self.assertFalse(root.b[0] >= root.b[1]) 812 self.assertFalse(root.b[0] > root.b[1]) 813 814 self.assertFalse(root.b[0]) 815 self.assert_(root.b[1]) 816 817 self.assertEquals(root.b[0], False) 818 self.assertEquals(False, root.b[0]) 819 self.assert_(root.b[0] < 5) 820 self.assert_(5 > root.b[0]) 821 822 root.b = True 823 self.assert_(root.b) 824 root.b = False 825 self.assertFalse(root.b)

826

827 - def test_type_none_cmp(self):

828 XML = self.XML 829 root = XML(u""" 830 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 831  832 </root>""") 833 self.assert_(root.b[0] == root.b[1]) 834 self.assertFalse(root.b[0]) 835 self.assertEquals(root.b[0], None) 836 self.assertEquals(None, root.b[0]) 837 838 for comparison in ["abc", 5, 7.3, True, [], ()]: 839 none = root.b[1] 840 self.assert_(none < comparison, "%s (%s) should be < %s" % 841 (none, type(none), comparison) ) 842 self.assert_(comparison > none, "%s should be > %s (%s)" % 843 (comparison, none, type(none)))

844

845 - def test_type_str_mod(self):

846 s = "%d %f %s %r" 847 el = objectify.DataElement(s) 848 values = (1, 7.0, "abcd", None) 849 self.assertEquals(s % values, el % values) 850 851 s = "%d" 852 el = objectify.DataElement(s) 853 val = 5 854 self.assertEquals(s % val, el % val) 855 856 s = "%d %s" 857 el = objectify.DataElement(s) 858 val = 5 859 self.assertRaises(TypeError, el.__mod__, val) 860 861 s = "" 862 el = objectify.DataElement(s) 863 val = 5 864 self.assertRaises(TypeError, el.__mod__, val)

865

866 - def test_pytype_annotation(self):

867 XML = self.XML 868 root = XML(u'''\ 869 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 870 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 871 5 872 test 873 <c>1.1</c> 874 <c>\uF8D2</c> 875 <x>true</x> 876 <n xsi:nil="true" /> 877 <n></n> 878 5 879 5 880 <s xsi:type="string">23</s> 881 <s py:pytype="str">42</s> 882 <f py:pytype="float">300</f> 883 <l py:pytype="long">2</l> 884 </a> 885 ''') 886 objectify.annotate(root) 887 888 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 889 for c in root.iterchildren() ] 890 self.assertEquals("int", child_types[ 0]) 891 self.assertEquals("str", child_types[ 1]) 892 self.assertEquals("float", child_types[ 2]) 893 self.assertEquals("str", child_types[ 3]) 894 self.assertEquals("bool", child_types[ 4]) 895 self.assertEquals("none", child_types[ 5]) 896 self.assertEquals(None, child_types[ 6]) 897 self.assertEquals("float", child_types[ 7]) 898 self.assertEquals("float", child_types[ 8]) 899 self.assertEquals("str", child_types[ 9]) 900 self.assertEquals("int", child_types[10]) 901 self.assertEquals("int", child_types[11]) 902 self.assertEquals("int", child_types[12]) 903 904 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

905

906 - def test_pytype_annotation_use_old(self):

907 XML = self.XML 908 root = XML(u'''\ 909 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 910 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 911 5 912 test 913 <c>1.1</c> 914 <c>\uF8D2</c> 915 <x>true</x> 916 <n xsi:nil="true" /> 917 <n></n> 918 5 919 5 920 <s xsi:type="string">23</s> 921 <s py:pytype="str">42</s> 922 <f py:pytype="float">300</f> 923 <l py:pytype="long">2</l> 924 </a> 925 ''') 926 objectify.annotate(root, ignore_old=False) 927 928 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 929 for c in root.iterchildren() ] 930 self.assertEquals("int", child_types[ 0]) 931 self.assertEquals("str", child_types[ 1]) 932 self.assertEquals("float", child_types[ 2]) 933 self.assertEquals("str", child_types[ 3]) 934 self.assertEquals("bool", child_types[ 4]) 935 self.assertEquals("none", child_types[ 5]) 936 self.assertEquals(None, child_types[ 6]) 937 self.assertEquals("float", child_types[ 7]) 938 self.assertEquals("float", child_types[ 8]) 939 self.assertEquals("str", child_types[ 9]) 940 self.assertEquals("str", child_types[10]) 941 self.assertEquals("float", child_types[11]) 942 self.assertEquals("long", child_types[12]) 943 944 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

945

946 - def test_deannotate(self):

947 XML = self.XML 948 root = XML(u'''\ 949 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 950 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 951 5 952 test 953 <c>1.1</c> 954 <c>\uF8D2</c> 955 <x>true</x> 956 <n xsi:nil="true" /> 957 <n></n> 958 5 959 5 960 <s xsi:type="string">23</s> 961 <s py:pytype="str">42</s> 962 <f py:pytype="float">300</f> 963 <l py:pytype="long">2</l> 964 </a> 965 ''') 966 objectify.deannotate(root) 967 968 for c in root.getiterator(): 969 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 970 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 971 972 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

973

974 - def test_xsitype_deannotate(self):

975 XML = self.XML 976 root = XML(u'''\ 977 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 978 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 979 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 980 5 981 test 982 <c>1.1</c> 983 <c>\uF8D2</c> 984 <x>true</x> 985 <n xsi:nil="true" /> 986 <n></n> 987 5 988 5 989 <s xsi:type="xsd:string">23</s> 990 <s py:pytype="str">42</s> 991 <f py:pytype="float">300</f> 992 <l py:pytype="long">2</l> 993 </a> 994 ''') 995 objectify.annotate(root) 996 objectify.deannotate(root, pytype=False) 997 998 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 999 for c in root.iterchildren() ] 1000 self.assertEquals("int", child_types[ 0]) 1001 self.assertEquals("str", child_types[ 1]) 1002 self.assertEquals("float", child_types[ 2]) 1003 self.assertEquals("str", child_types[ 3]) 1004 self.assertEquals("bool", child_types[ 4]) 1005 self.assertEquals("none", child_types[ 5]) 1006 self.assertEquals(None, child_types[ 6]) 1007 self.assertEquals("float", child_types[ 7]) 1008 self.assertEquals("float", child_types[ 8]) 1009 self.assertEquals("str", child_types[ 9]) 1010 self.assertEquals("int", child_types[10]) 1011 self.assertEquals("int", child_types[11]) 1012 self.assertEquals("int", child_types[12]) 1013 1014 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1015 1016 for c in root.getiterator(): 1017 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))

1018

1019 - def test_pytype_deannotate(self):

1020 XML = self.XML 1021 root = XML(u'''\ 1022 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1023 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1024 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1025 5 1026 test 1027 <c xsi:type="xsd:float">1.1</c> 1028 <c xsi:type="xsd:string">\uF8D2</c> 1029 <x xsi:type="xsd:boolean">true</x> 1030 <n xsi:nil="true" /> 1031 <n></n> 1032 5 1033 5 1034 <s xsi:type="xsd:string">23</s> 1035 <s xsi:type="xsd:string">42</s> 1036 <f xsi:type="xsd:float">300</f> 1037 <l xsi:type="xsd:long">2</l> 1038 </a> 1039 ''') 1040 objectify.annotate(root) 1041 objectify.deannotate(root, xsi=False) 1042 1043 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1044 for c in root.iterchildren() ] 1045 self.assertEquals("xsd:int", child_types[ 0]) 1046 self.assertEquals("xsd:string", child_types[ 1]) 1047 self.assertEquals("xsd:float", child_types[ 2]) 1048 self.assertEquals("xsd:string", child_types[ 3]) 1049 self.assertEquals("xsd:boolean", child_types[ 4]) 1050 self.assertEquals(None, child_types[ 5]) 1051 self.assertEquals(None, child_types[ 6]) 1052 self.assertEquals("xsd:double", child_types[ 7]) 1053 self.assertEquals("xsd:float", child_types[ 8]) 1054 self.assertEquals("xsd:string", child_types[ 9]) 1055 self.assertEquals("xsd:string", child_types[10]) 1056 self.assertEquals("xsd:float", child_types[11]) 1057 self.assertEquals("xsd:long", child_types[12]) 1058 1059 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1060 1061 for c in root.getiterator(): 1062 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))

1063

1064 - def test_change_pytype_attribute(self):

1065 XML = self.XML 1066 1067 xml = u'''\ 1068 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1069 5 1070 test 1071 <c>1.1</c> 1072 <c>\uF8D2</c> 1073 <x>true</x> 1074 <n xsi:nil="true" /> 1075 <n></n> 1076 5 1077 </a> 1078 ''' 1079 1080 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1081 objectify.setPytypeAttributeTag("{TEST}test") 1082 1083 root = XML(xml) 1084 objectify.annotate(root) 1085 1086 attribs = root.xpath("//@py:%s" % pytype_name, {"py" : pytype_ns}) 1087 self.assertEquals(0, len(attribs)) 1088 attribs = root.xpath("//@py:test", {"py" : "TEST"}) 1089 self.assertEquals(7, len(attribs)) 1090 1091 objectify.setPytypeAttributeTag() 1092 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1093 1094 self.assertNotEqual("test", pytype_ns.lower()) 1095 self.assertNotEqual("test", pytype_name.lower()) 1096 1097 root = XML(xml) 1098 attribs = root.xpath("//@py:%s" % pytype_name, {"py" : pytype_ns}) 1099 self.assertEquals(0, len(attribs)) 1100 1101 objectify.annotate(root) 1102 attribs = root.xpath("//@py:%s" % pytype_name, {"py" : pytype_ns}) 1103 self.assertEquals(7, len(attribs))

1104

1105 - def test_registered_types(self):

1106 orig_types = objectify.getRegisteredTypes() 1107 1108 try: 1109 orig_types[0].unregister() 1110 self.assertEquals(orig_types[1:], objectify.getRegisteredTypes()) 1111 1112 class NewType(objectify.ObjectifiedDataElement): 1113 pass

1114 1115 def checkMyType(s): 1116 return True

Source Code for Module lxml.tests.test_objectify