lxml.tests.test

1 # -*- coding: utf-8 -*- 2 3 """ 4 Tests specific to the lxml.objectify API 5 """ 6 7 8 import unittest, operator 9 10 from common_imports import etree, StringIO, HelperTestCase, fileInTestDir 11 from common_imports import SillyFileLike, canonicalize, doctest 12 13 from lxml import objectify 14 15 PYTYPE_NAMESPACE = "http://codespeak.net/lxml/objectify/pytype" 16 XML_SCHEMA_NS = "http://www.w3.org/2001/XMLSchema" 17 XML_SCHEMA_INSTANCE_NS = "http://www.w3.org/2001/XMLSchema-instance" 18 XML_SCHEMA_INSTANCE_TYPE_ATTR = "{%s}type" % XML_SCHEMA_INSTANCE_NS 19 XML_SCHEMA_NIL_ATTR = "{%s}nil" % XML_SCHEMA_INSTANCE_NS 20 TREE_PYTYPE = "TREE" 21 DEFAULT_NSMAP = { "py" : PYTYPE_NAMESPACE, 22 "xsi" : XML_SCHEMA_INSTANCE_NS, 23 "xsd" : XML_SCHEMA_NS} 24 25 objectclass2xsitype = { 26 # objectify built-in 27 objectify.IntElement: ("int", "short", "byte", "unsignedShort", 28 "unsignedByte",), 29 objectify.LongElement: ("integer", "nonPositiveInteger", "negativeInteger", 30 "long", "nonNegativeInteger", "unsignedLong", 31 "unsignedInt", "positiveInteger",), 32 objectify.FloatElement: ("float", "double"), 33 objectify.BoolElement: ("boolean",), 34 objectify.StringElement: ("string", "normalizedString", "token", "language", 35 "Name", "NCName", "ID", "IDREF", "ENTITY", 36 "NMTOKEN", ), 37 # None: xsi:nil="true" 38 } 39 40 xsitype2objclass = dict(( (v, k) for k in objectclass2xsitype 41 for v in objectclass2xsitype[k] )) 42 43 objectclass2pytype = { 44 # objectify built-in 45 objectify.IntElement: "int", 46 objectify.LongElement: "long", 47 objectify.FloatElement: "float", 48 objectify.BoolElement: "bool", 49 objectify.StringElement: "str", 50 # None: xsi:nil="true" 51 } 52 53 pytype2objclass = dict(( (objectclass2pytype[k], k) for k in objectclass2pytype)) 54 55 xml_str = '''\ 56 <obj:root xmlns:obj="objectified" xmlns:other="otherNS"> 57 <obj:c1 a1="A1" a2="A2" other:a3="A3"> 58 <obj:c2>0</obj:c2> 59 <obj:c2>1</obj:c2> 60 <obj:c2>2</obj:c2> 61 <other:c2>3</other:c2> 62 <c2>3</c2> 63 </obj:c1> 64 </obj:root>''' 65

66 -class ObjectifyTestCase(HelperTestCase):

67 """Test cases for lxml.objectify 68 """ 69 etree = etree 70

71 - def XML(self, xml):

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

73

74 - def setUp(self):

75 super(ObjectifyTestCase, self).setUp() 76 self.parser = self.etree.XMLParser(remove_blank_text=True) 77 self.lookup = etree.ElementNamespaceClassLookup( 78 objectify.ObjectifyElementClassLookup() ) 79 self.parser.setElementClassLookup(self.lookup) 80 81 self.Element = self.parser.makeelement 82 83 ns = self.lookup.get_namespace("otherNS") 84 ns[None] = self.etree.ElementBase

85

86 - def tearDown(self):

87 self.lookup.get_namespace("otherNS").clear() 88 objectify.setPytypeAttributeTag() 89 del self.lookup 90 del self.parser 91 super(ObjectifyTestCase, self).tearDown()

92

93 - def test_element_nsmap_default(self):

94 elt = objectify.Element("test") 95 self.assertEquals(elt.nsmap, DEFAULT_NSMAP)

96

97 - def test_element_nsmap_empty(self):

98 nsmap = {} 99 elt = objectify.Element("test", nsmap=nsmap) 100 self.assertEquals(elt.nsmap.values(), [PYTYPE_NAMESPACE])

101

102 - def test_element_nsmap_custom_prefixes(self):

103 nsmap = {"mypy": PYTYPE_NAMESPACE, 104 "myxsi": XML_SCHEMA_INSTANCE_NS, 105 "myxsd": XML_SCHEMA_NS} 106 elt = objectify.Element("test", nsmap=nsmap) 107 self.assertEquals(elt.nsmap, nsmap)

108

109 - def test_element_nsmap_custom(self):

110 nsmap = {"my": "someNS", 111 "myother": "someOtherNS", 112 "myxsd": XML_SCHEMA_NS} 113 elt = objectify.Element("test", nsmap=nsmap) 114 self.assert_(PYTYPE_NAMESPACE in elt.nsmap.values()) 115 for prefix, ns in nsmap.items(): 116 self.assert_(prefix in elt.nsmap) 117 self.assertEquals(nsmap[prefix], elt.nsmap[prefix])

118

119 - def test_sub_element_nsmap_default(self):

120 root = objectify.Element("root") 121 root.sub = objectify.Element("test") 122 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)

123

124 - def test_sub_element_nsmap_empty(self):

125 root = objectify.Element("root") 126 nsmap = {} 127 root.sub = objectify.Element("test", nsmap=nsmap) 128 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)

129

130 - def test_sub_element_nsmap_custom_prefixes(self):

131 root = objectify.Element("root") 132 nsmap = {"mypy": PYTYPE_NAMESPACE, 133 "myxsi": XML_SCHEMA_INSTANCE_NS, 134 "myxsd": XML_SCHEMA_NS} 135 root.sub = objectify.Element("test", nsmap=nsmap) 136 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)

137

138 - def test_sub_element_nsmap_custom(self):

139 root = objectify.Element("root") 140 nsmap = {"my": "someNS", 141 "myother": "someOtherNS", 142 "myxsd": XML_SCHEMA_NS,} 143 root.sub = objectify.Element("test", nsmap=nsmap) 144 expected = nsmap.copy() 145 del expected["myxsd"] 146 expected.update(DEFAULT_NSMAP) 147 self.assertEquals(root.sub.nsmap, expected)

148

149 - def test_data_element_nsmap_default(self):

150 value = objectify.DataElement("test this") 151 self.assertEquals(value.nsmap, DEFAULT_NSMAP)

152

153 - def test_data_element_nsmap_empty(self):

154 nsmap = {} 155 value = objectify.DataElement("test this", nsmap=nsmap) 156 self.assertEquals(value.nsmap.values(), [PYTYPE_NAMESPACE])

157

158 - def test_data_element_nsmap_custom_prefixes(self):

159 nsmap = {"mypy": PYTYPE_NAMESPACE, 160 "myxsi": XML_SCHEMA_INSTANCE_NS, 161 "myxsd": XML_SCHEMA_NS} 162 value = objectify.DataElement("test this", nsmap=nsmap) 163 self.assertEquals(value.nsmap, nsmap)

164

165 - def test_data_element_nsmap_custom(self):

166 nsmap = {"my": "someNS", 167 "myother": "someOtherNS", 168 "myxsd": XML_SCHEMA_NS,} 169 value = objectify.DataElement("test", nsmap=nsmap) 170 self.assert_(PYTYPE_NAMESPACE in value.nsmap.values()) 171 for prefix, ns in nsmap.items(): 172 self.assert_(prefix in value.nsmap) 173 self.assertEquals(nsmap[prefix], value.nsmap[prefix])

174

175 - def test_sub_data_element_nsmap_default(self):

176 root = objectify.Element("root") 177 root.value = objectify.DataElement("test this") 178 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)

179

180 - def test_sub_data_element_nsmap_empty(self):

181 root = objectify.Element("root") 182 nsmap = {} 183 root.value = objectify.DataElement("test this", nsmap=nsmap) 184 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)

185

186 - def test_sub_data_element_nsmap_custom_prefixes(self):

187 root = objectify.Element("root") 188 nsmap = {"mypy": PYTYPE_NAMESPACE, 189 "myxsi": XML_SCHEMA_INSTANCE_NS, 190 "myxsd": XML_SCHEMA_NS} 191 root.value = objectify.DataElement("test this", nsmap=nsmap) 192 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)

193

194 - def test_sub_data_element_nsmap_custom(self):

195 root = objectify.Element("root") 196 nsmap = {"my": "someNS", 197 "myother": "someOtherNS", 198 "myxsd": XML_SCHEMA_NS} 199 root.value = objectify.DataElement("test", nsmap=nsmap) 200 expected = nsmap.copy() 201 del expected["myxsd"] 202 expected.update(DEFAULT_NSMAP) 203 self.assertEquals(root.value.nsmap, expected)

204

205 - def test_data_element_attrib_attributes_precedence(self):

206 # keyword arguments override attrib entries 207 value = objectify.DataElement(23, _pytype="str", _xsi="foobar", 208 attrib={"gnu": "muh", "cat": "meeow", 209 "dog": "wuff"}, 210 bird="tchilp", dog="grrr") 211 self.assertEquals(value.get("gnu"), "muh") 212 self.assertEquals(value.get("cat"), "meeow") 213 self.assertEquals(value.get("dog"), "grrr") 214 self.assertEquals(value.get("bird"), "tchilp")

215

216 - def test_data_element_data_element_arg(self):

217 # Check that DataElement preserves all attributes ObjectifiedDataElement 218 # arguments 219 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 220 attrib={"gnu": "muh", "cat": "meeow", 221 "dog": "wuff"}, 222 bird="tchilp", dog="grrr") 223 value = objectify.DataElement(arg) 224 self.assert_(isinstance(value, objectify.StringElement)) 225 for attr in arg.attrib: 226 self.assertEquals(value.get(attr), arg.get(attr))

227

228 - def test_data_element_data_element_arg_pytype_none(self):

229 # Check that _pytype arg overrides original py:pytype of 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, _pytype="NoneType") 236 self.assert_(isinstance(value, objectify.NoneElement)) 237 self.assertEquals(value.get(XML_SCHEMA_NIL_ATTR), "true") 238 self.assertEquals(value.text, None) 239 self.assertEquals(value.pyval, None) 240 for attr in arg.attrib: 241 #if not attr == objectify.PYTYPE_ATTRIBUTE: 242 self.assertEquals(value.get(attr), arg.get(attr))

243

244 - def test_data_element_data_element_arg_pytype(self):

245 # Check that _pytype arg overrides original py:pytype of 246 # 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") 252 self.assert_(isinstance(value, objectify.IntElement)) 253 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 254 for attr in arg.attrib: 255 if not attr == objectify.PYTYPE_ATTRIBUTE: 256 self.assertEquals(value.get(attr), arg.get(attr))

257

258 - def test_data_element_data_element_arg_xsitype(self):

259 # Check that _xsi arg overrides original xsi:type of given 260 # ObjectifiedDataElement 261 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 262 attrib={"gnu": "muh", "cat": "meeow", 263 "dog": "wuff"}, 264 bird="tchilp", dog="grrr") 265 value = objectify.DataElement(arg, _xsi="xsd:int") 266 self.assert_(isinstance(value, objectify.IntElement)) 267 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 268 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 269 for attr in arg.attrib: 270 if not attr in [objectify.PYTYPE_ATTRIBUTE, 271 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 272 self.assertEquals(value.get(attr), arg.get(attr))

273

274 - def test_data_element_data_element_arg_pytype_xsitype(self):

275 # Check that _pytype and _xsi args override original py:pytype and 276 # xsi:type attributes of given ObjectifiedDataElement 277 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 278 attrib={"gnu": "muh", "cat": "meeow", 279 "dog": "wuff"}, 280 bird="tchilp", dog="grrr") 281 value = objectify.DataElement(arg, _pytype="int", _xsi="xsd:int") 282 self.assert_(isinstance(value, objectify.IntElement)) 283 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 284 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 285 for attr in arg.attrib: 286 if not attr in [objectify.PYTYPE_ATTRIBUTE, 287 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 288 self.assertEquals(value.get(attr), arg.get(attr))

289

290 - def test_data_element_invalid_pytype(self):

291 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 292 _pytype="int")

293

294 - def test_data_element_invalid_xsi(self):

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

297

298 - def test_data_element_data_element_arg_invalid_pytype(self):

299 arg = objectify.DataElement(3.1415) 300 self.assertRaises(ValueError, objectify.DataElement, arg, 301 _pytype="int")

302

303 - def test_data_element_data_element_arg_invalid_xsi(self):

304 arg = objectify.DataElement(3.1415) 305 self.assertRaises(ValueError, objectify.DataElement, arg, 306 _xsi="xsd:int")

307

308 - def test_root(self):

309 root = self.Element("test") 310 self.assert_(isinstance(root, objectify.ObjectifiedElement))

311

312 - def test_str(self):

313 root = self.Element("test") 314 self.assertEquals('', str(root))

315

316 - def test_child(self):

317 root = self.XML(xml_str) 318 self.assertEquals("0", root.c1.c2.text)

319

320 - def test_countchildren(self):

321 root = self.XML(xml_str) 322 self.assertEquals(1, root.countchildren()) 323 self.assertEquals(5, root.c1.countchildren())

324

325 - def test_child_getattr(self):

326 root = self.XML(xml_str) 327 self.assertEquals("0", getattr(root.c1, "{objectified}c2").text) 328 self.assertEquals("3", getattr(root.c1, "{otherNS}c2").text)

329

330 - def test_child_nonexistant(self):

331 root = self.XML(xml_str) 332 self.assertRaises(AttributeError, getattr, root.c1, "NOT_THERE") 333 self.assertRaises(AttributeError, getattr, root.c1, "{unknownNS}c2")

334

335 - def test_addattr(self):

336 root = self.XML(xml_str) 337 self.assertEquals(1, len(root.c1)) 338 root.addattr("c1", "test") 339 self.assertEquals(2, len(root.c1)) 340 self.assertEquals("test", root.c1[1].text)

341

342 - def test_addattr_element(self):

343 root = self.XML(xml_str) 344 self.assertEquals(1, len(root.c1)) 345 346 new_el = self.Element("test", myattr="5") 347 root.addattr("c1", new_el) 348 self.assertEquals(2, len(root.c1)) 349 self.assertEquals(None, root.c1[0].get("myattr")) 350 self.assertEquals("5", root.c1[1].get("myattr"))

351

352 - def test_addattr_list(self):

353 root = self.XML(xml_str) 354 self.assertEquals(1, len(root.c1)) 355 356 new_el = self.Element("test") 357 self.etree.SubElement(new_el, "a", myattr="A") 358 self.etree.SubElement(new_el, "a", myattr="B") 359 360 root.addattr("c1", list(new_el.a)) 361 self.assertEquals(3, len(root.c1)) 362 self.assertEquals(None, root.c1[0].get("myattr")) 363 self.assertEquals("A", root.c1[1].get("myattr")) 364 self.assertEquals("B", root.c1[2].get("myattr"))

365

366 - def test_child_addattr(self):

367 root = self.XML(xml_str) 368 self.assertEquals(3, len(root.c1.c2)) 369 root.c1.addattr("c2", 3) 370 self.assertEquals(4, len(root.c1.c2)) 371 self.assertEquals("3", root.c1.c2[3].text)

372

373 - def test_child_index(self):

374 root = self.XML(xml_str) 375 self.assertEquals("0", root.c1.c2[0].text) 376 self.assertEquals("1", root.c1.c2[1].text) 377 self.assertEquals("2", root.c1.c2[2].text) 378 self.assertRaises(IndexError, operator.getitem, root.c1.c2, 3)

379

380 - def test_child_index_neg(self):

381 root = self.XML(xml_str) 382 self.assertEquals("0", root.c1.c2[0].text) 383 self.assertEquals("0", root.c1.c2[-3].text) 384 self.assertEquals("1", root.c1.c2[-2].text) 385 self.assertEquals("2", root.c1.c2[-1].text) 386 self.assertRaises(IndexError, operator.getitem, root.c1.c2, -4)

387

388 - def test_child_len(self):

389 root = self.XML(xml_str) 390 self.assertEquals(1, len(root)) 391 self.assertEquals(1, len(root.c1)) 392 self.assertEquals(3, len(root.c1.c2))

393

394 - def test_child_iter(self):

395 root = self.XML(xml_str) 396 self.assertEquals([root], 397 list(iter(root))) 398 self.assertEquals([root.c1], 399 list(iter(root.c1))) 400 self.assertEquals([root.c1.c2[0], root.c1.c2[1], root.c1.c2[2]], 401 list(iter((root.c1.c2))))

402

403 - def test_class_lookup(self):

404 root = self.XML(xml_str) 405 self.assert_(isinstance(root.c1.c2, objectify.ObjectifiedElement)) 406 self.assertFalse(isinstance(getattr(root.c1, "{otherNS}c2"), 407 objectify.ObjectifiedElement))

408

409 - def test_dir(self):

410 root = self.XML(xml_str) 411 dir_c1 = dir(objectify.ObjectifiedElement) + ['c1'] 412 dir_c1.sort() 413 dir_c2 = dir(objectify.ObjectifiedElement) + ['c2'] 414 dir_c2.sort() 415 416 self.assertEquals(dir_c1, dir(root)) 417 self.assertEquals(dir_c2, dir(root.c1))

418

419 - def test_vars(self):

420 root = self.XML(xml_str) 421 self.assertEquals({'c1' : root.c1}, vars(root)) 422 self.assertEquals({'c2' : root.c1.c2}, vars(root.c1))

423

424 - def test_child_set_ro(self):

425 root = self.XML(xml_str) 426 self.assertRaises(TypeError, setattr, root.c1.c2, 'text', "test") 427 self.assertRaises(TypeError, setattr, root.c1.c2, 'pyval', "test")

428

429 - def test_setslice(self):

430 Element = self.Element 431 SubElement = self.etree.SubElement 432 root = Element("root") 433 root.c = ["c1", "c2"] 434 435 c1 = root.c[0] 436 c2 = root.c[1] 437 438 self.assertEquals([c1,c2], list(root.c)) 439 self.assertEquals(["c1", "c2"], 440 [ c.text for c in root.c ]) 441 442 root2 = Element("root2") 443 root2.el = [ "test", "test" ] 444 self.assertEquals(["test", "test"], 445 [ el.text for el in root2.el ]) 446 447 root.c = [ root2.el, root2.el ] 448 self.assertEquals(["test", "test"], 449 [ c.text for c in root.c ]) 450 self.assertEquals(["test", "test"], 451 [ el.text for el in root2.el ]) 452 453 root.c[:] = [ c1, c2, c2, c1 ] 454 self.assertEquals(["c1", "c2", "c2", "c1"], 455 [ c.text for c in root.c ])

456

457 - def test_set_string(self):

458 # make sure strings are not handled as sequences 459 Element = self.Element 460 SubElement = self.etree.SubElement 461 root = Element("root") 462 root.c = "TEST" 463 self.assertEquals(["TEST"], 464 [ c.text for c in root.c ])

465

466 - def test_setitem_string(self):

467 # make sure strings are set as children 468 Element = self.Element 469 SubElement = self.etree.SubElement 470 root = Element("root") 471 root["c"] = "TEST" 472 self.assertEquals(["TEST"], 473 [ c.text for c in root.c ])

474

475 - def test_setitem_string_special(self):

476 # make sure 'text' etc. are set as children 477 Element = self.Element 478 SubElement = self.etree.SubElement 479 root = Element("root") 480 481 root["text"] = "TEST" 482 self.assertEquals(["TEST"], 483 [ c.text for c in root["text"] ]) 484 485 root["tail"] = "TEST" 486 self.assertEquals(["TEST"], 487 [ c.text for c in root["tail"] ]) 488 489 root["pyval"] = "TEST" 490 self.assertEquals(["TEST"], 491 [ c.text for c in root["pyval"] ]) 492 493 root["tag"] = "TEST" 494 self.assertEquals(["TEST"], 495 [ c.text for c in root["tag"] ])

496

497 - def test_findall(self):

498 XML = self.XML 499 root = XML('<a><c/><c></c></a>') 500 self.assertEquals(1, len(root.findall("c"))) 501 self.assertEquals(2, len(root.findall(".//c"))) 502 self.assertEquals(3, len(root.findall(".//b"))) 503 self.assert_(root.findall(".//b")[1] is root.getchildren()[1])

504

505 - def test_findall_ns(self):

506 XML = self.XML 507 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>') 508 self.assertEquals(2, len(root.findall(".//{X}b"))) 509 self.assertEquals(3, len(root.findall(".//b"))) 510 self.assertEquals(2, len(root.findall("b")))

511

512 - def test_build_tree(self):

513 root = self.Element('root') 514 root.a = 5 515 root.b = 6 516 self.assert_(isinstance(root, objectify.ObjectifiedElement)) 517 self.assert_(isinstance(root.a, objectify.IntElement)) 518 self.assert_(isinstance(root.b, objectify.IntElement))

519

520 - def test_type_NoneType(self):

521 Element = self.Element 522 SubElement = self.etree.SubElement 523 524 nil_attr = XML_SCHEMA_NIL_ATTR 525 root = Element("{objectified}root") 526 SubElement(root, "{objectified}none") 527 SubElement(root, "{objectified}none", {nil_attr : "true"}) 528 self.assertFalse(isinstance(root.none, objectify.NoneElement)) 529 self.assertFalse(isinstance(root.none[0], objectify.NoneElement)) 530 self.assert_(isinstance(root.none[1], objectify.NoneElement)) 531 self.assertEquals(root.none[1], None) 532 self.assertFalse(root.none[1])

533

534 - def test_data_element_NoneType(self):

535 value = objectify.DataElement(None) 536 self.assert_(isinstance(value, objectify.NoneElement)) 537 self.assertEquals(value, None) 538 self.assertEquals(value.get(XML_SCHEMA_NIL_ATTR), "true")

539

540 - def test_type_bool(self):

541 Element = self.Element 542 SubElement = self.etree.SubElement 543 root = Element("{objectified}root") 544 root.bool = True 545 self.assertEquals(root.bool, True) 546 self.assert_(isinstance(root.bool, objectify.BoolElement)) 547 548 root.bool = False 549 self.assertEquals(root.bool, False) 550 self.assert_(isinstance(root.bool, objectify.BoolElement))

551

552 - def test_data_element_bool(self):

553 value = objectify.DataElement(True) 554 self.assert_(isinstance(value, objectify.BoolElement)) 555 self.assertEquals(value, True) 556 557 value = objectify.DataElement(False) 558 self.assert_(isinstance(value, objectify.BoolElement)) 559 self.assertEquals(value, False)

560

561 - def test_type_str(self):

562 Element = self.Element 563 SubElement = self.etree.SubElement 564 root = Element("{objectified}root") 565 root.s = "test" 566 self.assert_(isinstance(root.s, objectify.StringElement))

567

568 - def test_type_str_intliteral(self):

569 Element = self.Element 570 SubElement = self.etree.SubElement 571 root = Element("{objectified}root") 572 root.s = "3" 573 self.assert_(isinstance(root.s, objectify.StringElement))

574

575 - def test_type_str_floatliteral(self):

576 Element = self.Element 577 SubElement = self.etree.SubElement 578 root = Element("{objectified}root") 579 root.s = "3.72" 580 self.assert_(isinstance(root.s, objectify.StringElement))

581

582 - def test_type_str_mul(self):

583 Element = self.Element 584 SubElement = self.etree.SubElement 585 root = Element("{objectified}root") 586 root.s = "test" 587 588 self.assertEquals("test" * 5, root.s * 5) 589 self.assertEquals(5 * "test", 5 * root.s) 590 591 self.assertRaises(TypeError, operator.mul, root.s, "honk") 592 self.assertRaises(TypeError, operator.mul, "honk", root.s)

593

594 - def test_type_str_add(self):

595 Element = self.Element 596 SubElement = self.etree.SubElement 597 root = Element("{objectified}root") 598 root.s = "test" 599 600 s = "toast" 601 self.assertEquals("test" + s, root.s + s) 602 self.assertEquals(s + "test", s + root.s)

603

604 - def test_type_str_mod(self):

605 s = "%d %f %s %r" 606 el = objectify.DataElement(s) 607 values = (1, 7.0, "abcd", None) 608 self.assertEquals(s % values, el % values) 609 610 s = "%d" 611 el = objectify.DataElement(s) 612 val = 5 613 self.assertEquals(s % val, el % val) 614 615 s = "%d %s" 616 el = objectify.DataElement(s) 617 val = 5 618 self.assertRaises(TypeError, el.__mod__, val) 619 620 s = "" 621 el = objectify.DataElement(s) 622 val = 5 623 self.assertRaises(TypeError, el.__mod__, val)

624

625 - def test_type_str_mod_data_elements(self):

626 s = "%d %f %s %r" 627 el = objectify.DataElement(s) 628 values = (objectify.DataElement(1), 629 objectify.DataElement(7.0), 630 objectify.DataElement("abcd"), 631 objectify.DataElement(None)) 632 self.assertEquals(s % values, el % values)

633

634 - def test_data_element_str(self):

635 value = objectify.DataElement("test") 636 self.assert_(isinstance(value, objectify.StringElement)) 637 self.assertEquals(value, "test")

638

639 - def test_data_element_str_intliteral(self):

640 value = objectify.DataElement("3") 641 self.assert_(isinstance(value, objectify.StringElement)) 642 self.assertEquals(value, "3")

643

644 - def test_data_element_str_floatliteral(self):

645 value = objectify.DataElement("3.20") 646 self.assert_(isinstance(value, objectify.StringElement)) 647 self.assertEquals(value, "3.20")

648

649 - def test_type_ustr(self):

650 Element = self.Element 651 SubElement = self.etree.SubElement 652 root = Element("{objectified}root") 653 root.s = u"test" 654 self.assert_(isinstance(root.s, objectify.StringElement))

655

656 - def test_type_ustr_intliteral(self):

657 Element = self.Element 658 SubElement = self.etree.SubElement 659 root = Element("{objectified}root") 660 root.s = u"3" 661 self.assert_(isinstance(root.s, objectify.StringElement))

662

663 - def test_type_ustr_floatliteral(self):

664 Element = self.Element 665 SubElement = self.etree.SubElement 666 root = Element("{objectified}root") 667 root.s = u"3.72" 668 self.assert_(isinstance(root.s, objectify.StringElement))

669

670 - def test_type_ustr_mul(self):

671 Element = self.Element 672 SubElement = self.etree.SubElement 673 root = Element("{objectified}root") 674 root.s = u"test" 675 676 self.assertEquals(u"test" * 5, root.s * 5) 677 self.assertEquals(5 * u"test", 5 * root.s) 678 679 self.assertRaises(TypeError, operator.mul, root.s, u"honk") 680 self.assertRaises(TypeError, operator.mul, u"honk", root.s)

681

682 - def test_type_ustr_add(self):

683 Element = self.Element 684 SubElement = self.etree.SubElement 685 root = Element("{objectified}root") 686 root.s = u"test" 687 688 s = u"toast" 689 self.assertEquals(u"test" + s, root.s + s) 690 self.assertEquals(s + u"test", s + root.s)

691

692 - def test_data_element_ustr(self):

693 value = objectify.DataElement(u"test") 694 self.assert_(isinstance(value, objectify.StringElement)) 695 self.assertEquals(value, u"test")

696

697 - def test_data_element_ustr_intliteral(self):

698 value = objectify.DataElement("3") 699 self.assert_(isinstance(value, objectify.StringElement)) 700 self.assertEquals(value, u"3")

701

702 - def test_data_element_ustr_floatliteral(self):

703 value = objectify.DataElement(u"3.20") 704 self.assert_(isinstance(value, objectify.StringElement)) 705 self.assertEquals(value, u"3.20")

706

707 - def test_type_int(self):

708 Element = self.Element 709 SubElement = self.etree.SubElement 710 root = Element("{objectified}root") 711 root.none = 5 712 self.assert_(isinstance(root.none, objectify.IntElement))

713

714 - def test_data_element_int(self):

715 value = objectify.DataElement(5) 716 self.assert_(isinstance(value, objectify.IntElement)) 717 self.assertEquals(value, 5)

718

719 - def test_type_float(self):

720 Element = self.Element 721 SubElement = self.etree.SubElement 722 root = Element("{objectified}root") 723 root.none = 5.5 724 self.assert_(isinstance(root.none, objectify.FloatElement))

725

726 - def test_data_element_float(self):

727 value = objectify.DataElement(5.5) 728 self.assert_(isinstance(value, objectify.FloatElement)) 729 self.assertEquals(value, 5.5)

730

731 - def test_data_element_xsitypes(self):

732 for xsi, objclass in xsitype2objclass.iteritems(): 733 # 1 is a valid value for all ObjectifiedDataElement classes 734 pyval = 1 735 value = objectify.DataElement(pyval, _xsi=xsi) 736 self.assert_(isinstance(value, objclass), 737 "DataElement(%s, _xsi='%s') returns %s, expected %s" 738 % (pyval, xsi, type(value), objclass))

739

740 - def test_data_element_xsitypes_xsdprefixed(self):

741 for xsi, objclass in xsitype2objclass.iteritems(): 742 # 1 is a valid value for all ObjectifiedDataElement classes 743 pyval = 1 744 value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi) 745 self.assert_(isinstance(value, objclass), 746 "DataElement(%s, _xsi='%s') returns %s, expected %s" 747 % (pyval, xsi, type(value), objclass))

748

749 - def test_data_element_xsitypes_prefixed(self):

750 for xsi, objclass in xsitype2objclass.iteritems(): 751 # 1 is a valid value for all ObjectifiedDataElement classes 752 self.assertRaises(ValueError, objectify.DataElement, 1, 753 _xsi="foo:%s" % xsi)

754

755 - def test_data_element_pytypes(self):

756 for pytype, objclass in pytype2objclass.iteritems(): 757 # 1 is a valid value for all ObjectifiedDataElement classes 758 pyval = 1 759 value = objectify.DataElement(pyval, _pytype=pytype) 760 self.assert_(isinstance(value, objclass), 761 "DataElement(%s, _pytype='%s') returns %s, expected %s" 762 % (pyval, pytype, type(value), objclass))

763

764 - def test_data_element_pytype_none(self):

765 pyval = 1 766 pytype = "NoneType" 767 objclass = objectify.NoneElement 768 value = objectify.DataElement(pyval, _pytype=pytype) 769 self.assert_(isinstance(value, objclass), 770 "DataElement(%s, _pytype='%s') returns %s, expected %s" 771 % (pyval, pytype, type(value), objclass)) 772 self.assertEquals(value.text, None) 773 self.assertEquals(value.pyval, None)

774

775 - def test_data_element_pytype_none_compat(self):

776 # pre-2.0 lxml called NoneElement "none" 777 pyval = 1 778 pytype = "none" 779 objclass = objectify.NoneElement 780 value = objectify.DataElement(pyval, _pytype=pytype) 781 self.assert_(isinstance(value, objclass), 782 "DataElement(%s, _pytype='%s') returns %s, expected %s" 783 % (pyval, pytype, type(value), objclass)) 784 self.assertEquals(value.text, None) 785 self.assertEquals(value.pyval, None)

786

787 - def test_type_unregistered(self):

788 Element = self.Element 789 SubElement = self.etree.SubElement 790 class MyFloat(float): 791 pass

792 root = Element("{objectified}root") 793 root.myfloat = MyFloat(5.5) 794 self.assert_(isinstance(root.myfloat, objectify.FloatElement)) 795 self.assertEquals(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None)

796

797 - def test_data_element_unregistered(self):

798 class MyFloat(float): 799 pass

800 value = objectify.DataElement(MyFloat(5.5)) 801 self.assert_(isinstance(value, objectify.FloatElement)) 802 self.assertEquals(value, 5.5) 803 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), None) 804

805 - def test_schema_types(self):

806 XML = self.XML 807 root = XML('''\ 808 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 809 true 810 false 811 1 812 0 813 814 <f xsi:type="float">5</f> 815 <f xsi:type="double">5</f> 816 817 <s xsi:type="string">5</s> 818 <s xsi:type="normalizedString">5</s> 819 <s xsi:type="token">5</s> 820 <s xsi:type="language">5</s> 821 <s xsi:type="Name">5</s> 822 <s xsi:type="NCName">5</s> 823 <s xsi:type="ID">5</s> 824 <s xsi:type="IDREF">5</s> 825 <s xsi:type="ENTITY">5</s> 826 <s xsi:type="NMTOKEN">5</s> 827 828 <l xsi:type="integer">5</l> 829 <l xsi:type="nonPositiveInteger">5</l> 830 <l xsi:type="negativeInteger">5</l> 831 <l xsi:type="long">5</l> 832 <l xsi:type="nonNegativeInteger">5</l> 833 <l xsi:type="unsignedLong">5</l> 834 <l xsi:type="unsignedInt">5</l> 835 <l xsi:type="positiveInteger">5</l> 836 837 5 838 5 839 5 840 5 841 5 842 843 <n xsi:nil="true"/> 844 </root> 845 ''') 846 847 for b in root.b: 848 self.assert_(isinstance(b, objectify.BoolElement)) 849 self.assertEquals(True, root.b[0]) 850 self.assertEquals(False, root.b[1]) 851 self.assertEquals(True, root.b[2]) 852 self.assertEquals(False, root.b[3]) 853 854 for f in root.f: 855 self.assert_(isinstance(f, objectify.FloatElement)) 856 self.assertEquals(5, f) 857 858 for s in root.s: 859 self.assert_(isinstance(s, objectify.StringElement)) 860 self.assertEquals("5", s) 861 862 for l in root.l: 863 self.assert_(isinstance(l, objectify.LongElement)) 864 self.assertEquals(5L, l) 865 866 for i in root.i: 867 self.assert_(isinstance(i, objectify.IntElement)) 868 self.assertEquals(5, i) 869 870 self.assert_(isinstance(root.n, objectify.NoneElement)) 871 self.assertEquals(None, root.n)

872

873 - def test_schema_types_prefixed(self):

874 XML = self.XML 875 root = XML('''\ 876 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 877 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 878 true 879 false 880 1 881 0 882 883 <f xsi:type="xsd:float">5</f> 884 <f xsi:type="xsd:double">5</f> 885 886 <s xsi:type="xsd:string">5</s> 887 <s xsi:type="xsd:normalizedString">5</s> 888 <s xsi:type="xsd:token">5</s> 889 <s xsi:type="xsd:language">5</s> 890 <s xsi:type="xsd:Name">5</s> 891 <s xsi:type="xsd:NCName">5</s> 892 <s xsi:type="xsd:ID">5</s> 893 <s xsi:type="xsd:IDREF">5</s> 894 <s xsi:type="xsd:ENTITY">5</s> 895 <s xsi:type="xsd:NMTOKEN">5</s> 896 897 <l xsi:type="xsd:integer">5</l> 898 <l xsi:type="xsd:nonPositiveInteger">5</l> 899 <l xsi:type="xsd:negativeInteger">5</l> 900 <l xsi:type="xsd:long">5</l> 901 <l xsi:type="xsd:nonNegativeInteger">5</l> 902 <l xsi:type="xsd:unsignedLong">5</l> 903 <l xsi:type="xsd:unsignedInt">5</l> 904 <l xsi:type="xsd:positiveInteger">5</l> 905 906 5 907 5 908 5 909 5 910 5 911 912 <n xsi:nil="true"/> 913 </root> 914 ''') 915 916 for b in root.b: 917 self.assert_(isinstance(b, objectify.BoolElement)) 918 self.assertEquals(True, root.b[0]) 919 self.assertEquals(False, root.b[1]) 920 self.assertEquals(True, root.b[2]) 921 self.assertEquals(False, root.b[3]) 922 923 for f in root.f: 924 self.assert_(isinstance(f, objectify.FloatElement)) 925 self.assertEquals(5, f) 926 927 for s in root.s: 928 self.assert_(isinstance(s, objectify.StringElement)) 929 self.assertEquals("5", s) 930 931 for l in root.l: 932 self.assert_(isinstance(l, objectify.LongElement)) 933 self.assertEquals(5L, l) 934 935 for i in root.i: 936 self.assert_(isinstance(i, objectify.IntElement)) 937 self.assertEquals(5, i) 938 939 self.assert_(isinstance(root.n, objectify.NoneElement)) 940 self.assertEquals(None, root.n)

941

942 - def test_type_str_sequence(self):

943 XML = self.XML 944 root = XML(u'<root>whytry</root>') 945 strs = [ str(s) for s in root.b ] 946 self.assertEquals(["why", "try"], 947 strs)

948

949 - def test_type_str_cmp(self):

950 XML = self.XML 951 root = XML(u'<root>testtaste</root>') 952 self.assertFalse(root.b[0] < root.b[1]) 953 self.assertFalse(root.b[0] <= root.b[1]) 954 self.assertFalse(root.b[0] == root.b[1]) 955 956 self.assert_(root.b[0] != root.b[1]) 957 self.assert_(root.b[0] >= root.b[1]) 958 self.assert_(root.b[0] > root.b[1]) 959 960 self.assertEquals(root.b[0], "test") 961 self.assertEquals("test", root.b[0]) 962 self.assert_(root.b[0] > 5) 963 self.assert_(5 < root.b[0]) 964 965 self.assertEquals("", root.b[2]) 966 self.assertEquals(root.b[2], "") 967 self.assertEquals("", root.b[3]) 968 self.assertEquals(root.b[3], "") 969 self.assertEquals(root.b[2], root.b[3]) 970 971 root.b = "test" 972 self.assert_(root.b) 973 root.b = "" 974 self.assertFalse(root.b) 975 self.assertEquals(root.b, "") 976 self.assertEquals("", root.b)

977

978 - def test_type_int_cmp(self):

979 XML = self.XML 980 root = XML(u'<root>56</root>') 981 self.assert_(root.b[0] < root.b[1]) 982 self.assert_(root.b[0] <= root.b[1]) 983 self.assert_(root.b[0] != root.b[1]) 984 985 self.assertFalse(root.b[0] == root.b[1]) 986 self.assertFalse(root.b[0] >= root.b[1]) 987 self.assertFalse(root.b[0] > root.b[1]) 988 989 self.assertEquals(root.b[0], 5) 990 self.assertEquals(5, root.b[0]) 991 self.assert_(root.b[0] < "5") 992 self.assert_("5" > root.b[0]) 993 994 root.b = 5 995 self.assert_(root.b) 996 root.b = 0 997 self.assertFalse(root.b)

998 999 # float + long share the NumberElement implementation with int 1000

1001 - def test_type_bool_cmp(self):

1002 XML = self.XML 1003 root = XML(u'<root>falsetrue</root>') 1004 self.assert_(root.b[0] < root.b[1]) 1005 self.assert_(root.b[0] <= root.b[1]) 1006 self.assert_(root.b[0] != root.b[1]) 1007 1008 self.assertFalse(root.b[0] == root.b[1]) 1009 self.assertFalse(root.b[0] >= root.b[1]) 1010 self.assertFalse(root.b[0] > root.b[1]) 1011 1012 self.assertFalse(root.b[0]) 1013 self.assert_(root.b[1]) 1014 1015 self.assertEquals(root.b[0], False) 1016 self.assertEquals(False, root.b[0]) 1017 self.assert_(root.b[0] < 5) 1018 self.assert_(5 > root.b[0]) 1019 1020 root.b = True 1021 self.assert_(root.b) 1022 root.b = False 1023 self.assertFalse(root.b)

1024

1025 - def test_type_none_cmp(self):

1026 XML = self.XML 1027 root = XML(u""" 1028 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1029  1030 </root>""") 1031 self.assert_(root.b[0] == root.b[1]) 1032 self.assertFalse(root.b[0]) 1033 self.assertEquals(root.b[0], None) 1034 self.assertEquals(None, root.b[0]) 1035 1036 for comparison in ["abc", 5, 7.3, True, [], ()]: 1037 none = root.b[1] 1038 self.assert_(none < comparison, "%s (%s) should be < %s" % 1039 (none, type(none), comparison) ) 1040 self.assert_(comparison > none, "%s should be > %s (%s)" % 1041 (comparison, none, type(none)) )

1042

1043 - def test_dataelement_xsi(self):

1044 el = objectify.DataElement(1, _xsi="string") 1045 self.assertEquals( 1046 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1047 'xsd:string')

1048

1049 - def test_dataelement_xsi_nsmap(self):

1050 el = objectify.DataElement(1, _xsi="string", 1051 nsmap={'schema': XML_SCHEMA_NS}) 1052 self.assertEquals( 1053 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1054 'schema:string')

1055

1056 - def test_dataelement_xsi_prefix_error(self):

1057 self.assertRaises(ValueError, objectify.DataElement, 1, 1058 _xsi="foo:string")

1059

1060 - def test_pytype_annotation(self):

1061 XML = self.XML 1062 root = XML(u'''\ 1063 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1064 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1065 5 1066 test 1067 <c>1.1</c> 1068 <c>\uF8D2</c> 1069 <x>true</x> 1070 <n xsi:nil="true" /> 1071 <n></n> 1072 5 1073 5 1074 <s xsi:type="string">23</s> 1075 <s py:pytype="str">42</s> 1076 <f py:pytype="float">300</f> 1077 <l py:pytype="long">2</l> 1078 <t py:pytype="TREE"></t> 1079 </a> 1080 ''') 1081 objectify.annotate(root) 1082 1083 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1084 for c in root.iterchildren() ] 1085 self.assertEquals("int", child_types[ 0]) 1086 self.assertEquals("str", child_types[ 1]) 1087 self.assertEquals("float", child_types[ 2]) 1088 self.assertEquals("str", child_types[ 3]) 1089 self.assertEquals("bool", child_types[ 4]) 1090 self.assertEquals("NoneType", child_types[ 5]) 1091 self.assertEquals(None, child_types[ 6]) 1092 self.assertEquals("float", child_types[ 7]) 1093 self.assertEquals("float", child_types[ 8]) 1094 self.assertEquals("str", child_types[ 9]) 1095 self.assertEquals("int", child_types[10]) 1096 self.assertEquals("int", child_types[11]) 1097 self.assertEquals("int", child_types[12]) 1098 self.assertEquals(None, child_types[13]) 1099 1100 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1101

1102 - def test_pytype_annotation_empty(self):

1103 XML = self.XML 1104 root = XML(u'''\ 1105 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1106 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1107 <n></n> 1108 </a> 1109 ''') 1110 objectify.annotate(root) 1111 1112 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1113 for c in root.iterchildren() ] 1114 self.assertEquals(None, child_types[0]) 1115 1116 objectify.annotate(root, empty_pytype="str") 1117 1118 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1119 for c in root.iterchildren() ] 1120 self.assertEquals("str", child_types[0])

1121

1122 - def test_pytype_annotation_use_old(self):

1123 XML = self.XML 1124 root = XML(u'''\ 1125 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1126 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1127 5 1128 test 1129 <c>1.1</c> 1130 <c>\uF8D2</c> 1131 <x>true</x> 1132 <n xsi:nil="true" /> 1133 <n></n> 1134 5 1135 5 1136 <s xsi:type="string">23</s> 1137 <s py:pytype="str">42</s> 1138 <f py:pytype="float">300</f> 1139 <l py:pytype="long">2</l> 1140 <t py:pytype="TREE"></t> 1141 </a> 1142 ''') 1143 objectify.annotate(root, ignore_old=False) 1144 1145 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1146 for c in root.iterchildren() ] 1147 self.assertEquals("int", child_types[ 0]) 1148 self.assertEquals("str", child_types[ 1]) 1149 self.assertEquals("float", child_types[ 2]) 1150 self.assertEquals("str", child_types[ 3]) 1151 self.assertEquals("bool", child_types[ 4]) 1152 self.assertEquals("NoneType", child_types[ 5]) 1153 self.assertEquals(None, child_types[ 6]) 1154 self.assertEquals("float", child_types[ 7]) 1155 self.assertEquals("float", child_types[ 8]) 1156 self.assertEquals("str", child_types[ 9]) 1157 self.assertEquals("str", child_types[10]) 1158 self.assertEquals("float", child_types[11]) 1159 self.assertEquals("long", child_types[12]) 1160 self.assertEquals(TREE_PYTYPE, child_types[13]) 1161 1162 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1163

1164 - def test_pytype_xsitype_annotation(self):

1165 XML = self.XML 1166 root = XML(u'''\ 1167 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1168 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1169 5 1170 test 1171 <c>1.1</c> 1172 <c>\uF8D2</c> 1173 <x>true</x> 1174 <n xsi:nil="true" /> 1175 <n></n> 1176 5 1177 5 1178 <s xsi:type="string">23</s> 1179 <s py:pytype="str">42</s> 1180 <f py:pytype="float">300</f> 1181 <l py:pytype="long">2</l> 1182 <t py:pytype="TREE"></t> 1183 </a> 1184 ''') 1185 objectify.annotate(root, ignore_old=False, ignore_xsi=False, 1186 annotate_xsi=1, annotate_pytype=1) 1187 1188 # check py annotations 1189 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1190 for c in root.iterchildren() ] 1191 self.assertEquals("int", child_types[ 0]) 1192 self.assertEquals("str", child_types[ 1]) 1193 self.assertEquals("float", child_types[ 2]) 1194 self.assertEquals("str", child_types[ 3]) 1195 self.assertEquals("bool", child_types[ 4]) 1196 self.assertEquals("NoneType", child_types[ 5]) 1197 self.assertEquals(None, child_types[ 6]) 1198 self.assertEquals("float", child_types[ 7]) 1199 self.assertEquals("float", child_types[ 8]) 1200 self.assertEquals("str", child_types[ 9]) 1201 self.assertEquals("str", child_types[10]) 1202 self.assertEquals("float", child_types[11]) 1203 self.assertEquals("long", child_types[12]) 1204 self.assertEquals(TREE_PYTYPE, child_types[13]) 1205 1206 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1207 1208 child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1209 for c in root.iterchildren() ] 1210 1211 # check xsi annotations 1212 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1213 for c in root.iterchildren() ] 1214 self.assertEquals("xsd:int", child_types[ 0]) 1215 self.assertEquals("xsd:string", child_types[ 1]) 1216 self.assertEquals("xsd:double", child_types[ 2]) 1217 self.assertEquals("xsd:string", child_types[ 3]) 1218 self.assertEquals("xsd:boolean", child_types[ 4]) 1219 self.assertEquals(None, child_types[ 5]) 1220 self.assertEquals(None, child_types[ 6]) 1221 self.assertEquals("xsd:double", child_types[ 7]) 1222 self.assertEquals("xsd:float", child_types[ 8]) 1223 self.assertEquals("xsd:string", child_types[ 9]) 1224 self.assertEquals("xsd:string", child_types[10]) 1225 self.assertEquals("xsd:double", child_types[11]) 1226 self.assertEquals("xsd:integer", child_types[12]) 1227 self.assertEquals(None, child_types[13]) 1228 1229 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1230

1231 - def test_xsiannotate_use_old(self):

1232 XML = self.XML 1233 root = XML(u'''\ 1234 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1235 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1236 5 1237 test 1238 <c>1.1</c> 1239 <c>\uF8D2</c> 1240 <x>true</x> 1241 <n xsi:nil="true" /> 1242 <n></n> 1243 5 1244 5 1245 <s xsi:type="string">23</s> 1246 <s py:pytype="str">42</s> 1247 <f py:pytype="float">300</f> 1248 <l py:pytype="long">2</l> 1249 <t py:pytype="TREE"></t> 1250 </a> 1251 ''') 1252 objectify.xsiannotate(root, ignore_old=False) 1253 1254 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1255 for c in root.iterchildren() ] 1256 self.assertEquals("xsd:int", child_types[ 0]) 1257 self.assertEquals("xsd:string", child_types[ 1]) 1258 self.assertEquals("xsd:double", child_types[ 2]) 1259 self.assertEquals("xsd:string", child_types[ 3]) 1260 self.assertEquals("xsd:boolean", child_types[ 4]) 1261 self.assertEquals(None, child_types[ 5]) 1262 self.assertEquals(None, child_types[ 6]) 1263 self.assertEquals("xsd:double", child_types[ 7]) 1264 self.assertEquals("xsd:float", child_types[ 8]) 1265 self.assertEquals("xsd:string", child_types[ 9]) 1266 self.assertEquals("xsd:string", child_types[10]) 1267 self.assertEquals("xsd:double", child_types[11]) 1268 self.assertEquals("xsd:integer", child_types[12]) 1269 self.assertEquals(None, child_types[13])

1270

1271 - def test_pyannotate_ignore_old(self):

1272 XML = self.XML 1273 root = XML(u'''\ 1274 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1275 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1276 5 1277 test 1278 <c>1.1</c> 1279 <c>\uF8D2</c> 1280 <x>true</x> 1281 <n xsi:nil="true" /> 1282 <n></n> 1283 5 1284 5 1285 <s xsi:type="string">23</s> 1286 <s py:pytype="str">42</s> 1287 <f py:pytype="float">300</f> 1288 <l py:pytype="long">2</l> 1289 <t py:pytype="TREE"></t> 1290 </a> 1291 ''') 1292 objectify.pyannotate(root, ignore_old=True) 1293 1294 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1295 for c in root.iterchildren() ] 1296 self.assertEquals("int", child_types[ 0]) 1297 self.assertEquals("str", child_types[ 1]) 1298 self.assertEquals("float", child_types[ 2]) 1299 self.assertEquals("str", child_types[ 3]) 1300 self.assertEquals("bool", child_types[ 4]) 1301 self.assertEquals("NoneType", child_types[ 5]) 1302 self.assertEquals(None, child_types[ 6]) 1303 self.assertEquals("float", child_types[ 7]) 1304 self.assertEquals("float", child_types[ 8]) 1305 self.assertEquals("str", child_types[ 9]) 1306 self.assertEquals("int", child_types[10]) 1307 self.assertEquals("int", child_types[11]) 1308 self.assertEquals("int", child_types[12]) 1309 self.assertEquals(None, child_types[13]) 1310 1311 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1312

1313 - def test_pyannotate_empty(self):

1314 XML = self.XML 1315 root = XML(u'''\ 1316 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1317 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1318 <n></n> 1319 </a> 1320 ''') 1321 objectify.pyannotate(root) 1322 1323 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1324 for c in root.iterchildren() ] 1325 self.assertEquals(None, child_types[0]) 1326 1327 objectify.annotate(root, empty_pytype="str") 1328 1329 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1330 for c in root.iterchildren() ] 1331 self.assertEquals("str", child_types[0])

1332

1333 - def test_pyannotate_use_old(self):

1334 XML = self.XML 1335 root = XML(u'''\ 1336 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1337 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1338 5 1339 test 1340 <c>1.1</c> 1341 <c>\uF8D2</c> 1342 <x>true</x> 1343 <n xsi:nil="true" /> 1344 <n></n> 1345 5 1346 5 1347 <s xsi:type="string">23</s> 1348 <s py:pytype="str">42</s> 1349 <f py:pytype="float">300</f> 1350 <l py:pytype="long">2</l> 1351 <t py:pytype="TREE"></t> 1352 </a> 1353 ''') 1354 objectify.pyannotate(root) 1355 1356 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1357 for c in root.iterchildren() ] 1358 self.assertEquals("int", child_types[ 0]) 1359 self.assertEquals("str", child_types[ 1]) 1360 self.assertEquals("float", child_types[ 2]) 1361 self.assertEquals("str", child_types[ 3]) 1362 self.assertEquals("bool", child_types[ 4]) 1363 self.assertEquals("NoneType", child_types[ 5]) 1364 self.assertEquals(None, child_types[ 6]) 1365 self.assertEquals("float", child_types[ 7]) 1366 self.assertEquals("float", child_types[ 8]) 1367 self.assertEquals("str", child_types[ 9]) 1368 self.assertEquals("str", child_types[10]) 1369 self.assertEquals("float", child_types[11]) 1370 self.assertEquals("long", child_types[12]) 1371 self.assertEquals(TREE_PYTYPE, child_types[13]) 1372 1373 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1374

1375 - def test_xsiannotate_ignore_old(self):

1376 XML = self.XML 1377 root = XML(u'''\ 1378 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1379 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1380 5 1381 test 1382 <c>1.1</c> 1383 <c>\uF8D2</c> 1384 <x>true</x> 1385 <n xsi:nil="true" /> 1386 <n></n> 1387 5 1388 5 1389 <s xsi:type="string">23</s> 1390 <s py:pytype="str">42</s> 1391 <f py:pytype="float">300</f> 1392 <l py:pytype="long">2</l> 1393 <t py:pytype="TREE"></t> 1394 </a> 1395 ''') 1396 objectify.xsiannotate(root, ignore_old=True) 1397 1398 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1399 for c in root.iterchildren() ] 1400 self.assertEquals("xsd:int", child_types[ 0]) 1401 self.assertEquals("xsd:string", child_types[ 1]) 1402 self.assertEquals("xsd:double", child_types[ 2]) 1403 self.assertEquals("xsd:string", child_types[ 3]) 1404 self.assertEquals("xsd:boolean", child_types[ 4]) 1405 self.assertEquals(None, child_types[ 5]) 1406 self.assertEquals(None, child_types[ 6]) 1407 self.assertEquals("xsd:int", child_types[ 7]) 1408 self.assertEquals("xsd:int", child_types[ 8]) 1409 self.assertEquals("xsd:int", child_types[ 9]) 1410 self.assertEquals("xsd:string", child_types[10]) 1411 self.assertEquals("xsd:double", child_types[11]) 1412 self.assertEquals("xsd:integer", child_types[12]) 1413 self.assertEquals(None, child_types[13]) 1414 1415 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1416

1417 - def test_deannotate(self):

1418 XML = self.XML 1419 root = XML(u'''\ 1420 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1421 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1422 5 1423 test 1424 <c>1.1</c> 1425 <c>\uF8D2</c> 1426 <x>true</x> 1427 <n xsi:nil="true" /> 1428 <n></n> 1429 5 1430 5 1431 <s xsi:type="string">23</s> 1432 <s py:pytype="str">42</s> 1433 <f py:pytype="float">300</f> 1434 <l py:pytype="long">2</l> 1435 <t py:pytype="TREE"></t> 1436 </a> 1437 ''') 1438 objectify.deannotate(root) 1439 1440 for c in root.getiterator(): 1441 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 1442 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1443 1444 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1445

1446 - def test_pytype_deannotate(self):

1447 XML = self.XML 1448 root = XML(u'''\ 1449 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1450 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1451 5 1452 test 1453 <c>1.1</c> 1454 <c>\uF8D2</c> 1455 <x>true</x> 1456 <n xsi:nil="true" /> 1457 <n></n> 1458 5 1459 5 1460 <s xsi:type="string">23</s> 1461 <s py:pytype="str">42</s> 1462 <f py:pytype="float">300</f> 1463 <l py:pytype="long">2</l> 1464 <t py:pytype="TREE"></t> 1465 </a> 1466 ''') 1467 objectify.xsiannotate(root) 1468 objectify.deannotate(root, xsi=False) 1469 1470 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1471 for c in root.iterchildren() ] 1472 self.assertEquals("xsd:int", child_types[ 0]) 1473 self.assertEquals("xsd:string", child_types[ 1]) 1474 self.assertEquals("xsd:double", child_types[ 2]) 1475 self.assertEquals("xsd:string", child_types[ 3]) 1476 self.assertEquals("xsd:boolean", child_types[ 4]) 1477 self.assertEquals(None, child_types[ 5]) 1478 self.assertEquals(None, child_types[ 6]) 1479 self.assertEquals("xsd:int", child_types[ 7]) 1480 self.assertEquals("xsd:int", child_types[ 8]) 1481 self.assertEquals("xsd:int", child_types[ 9]) 1482 self.assertEquals("xsd:string", child_types[10]) 1483 self.assertEquals("xsd:double", child_types[11]) 1484 self.assertEquals("xsd:integer", child_types[12]) 1485 self.assertEquals(None, child_types[13]) 1486 1487 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1488 1489 for c in root.getiterator(): 1490 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))

1491

1492 - def test_xsitype_deannotate(self):

1493 XML = self.XML 1494 root = XML(u'''\ 1495 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1496 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1497 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1498 5 1499 test 1500 <c>1.1</c> 1501 <c>\uF8D2</c> 1502 <x>true</x> 1503 <n xsi:nil="true" /> 1504 <n></n> 1505 5 1506 5 1507 <s xsi:type="xsd:string">23</s> 1508 <s py:pytype="str">42</s> 1509 <f py:pytype="float">300</f> 1510 <l py:pytype="long">2</l> 1511 <t py:pytype="TREE"></t> 1512 </a> 1513 ''') 1514 objectify.annotate(root) 1515 objectify.deannotate(root, pytype=False) 1516 1517 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1518 for c in root.iterchildren() ] 1519 self.assertEquals("int", child_types[ 0]) 1520 self.assertEquals("str", child_types[ 1]) 1521 self.assertEquals("float", child_types[ 2]) 1522 self.assertEquals("str", child_types[ 3]) 1523 self.assertEquals("bool", child_types[ 4]) 1524 self.assertEquals("NoneType", child_types[ 5]) 1525 self.assertEquals(None, child_types[ 6]) 1526 self.assertEquals("float", child_types[ 7]) 1527 self.assertEquals("float", child_types[ 8]) 1528 self.assertEquals("str", child_types[ 9]) 1529 self.assertEquals("int", child_types[10]) 1530 self.assertEquals("int", child_types[11]) 1531 self.assertEquals("int", child_types[12]) 1532 self.assertEquals(None, child_types[13]) 1533 1534 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1535 1536 for c in root.getiterator(): 1537 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))

1538

1539 - def test_pytype_deannotate(self):

1540 XML = self.XML 1541 root = XML(u'''\ 1542 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1543 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1544 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1545 5 1546 test 1547 <c xsi:type="xsd:float">1.1</c> 1548 <c xsi:type="xsd:string">\uF8D2</c> 1549 <x xsi:type="xsd:boolean">true</x> 1550 <n xsi:nil="true" /> 1551 <n></n> 1552 5 1553 5 1554 <s xsi:type="xsd:string">23</s> 1555 <s xsi:type="xsd:string">42</s> 1556 <f xsi:type="xsd:float">300</f> 1557 <l xsi:type="xsd:long">2</l> 1558 <t py:pytype="TREE"></t> 1559 </a> 1560 ''') 1561 objectify.annotate(root) 1562 objectify.deannotate(root, xsi=False) 1563 1564 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1565 for c in root.iterchildren() ] 1566 self.assertEquals("xsd:int", child_types[ 0]) 1567 self.assertEquals("xsd:string", child_types[ 1]) 1568 self.assertEquals("xsd:float", child_types[ 2]) 1569 self.assertEquals("xsd:string", child_types[ 3]) 1570 self.assertEquals("xsd:boolean", child_types[ 4]) 1571 self.assertEquals(None, child_types[ 5]) 1572 self.assertEquals(None, child_types[ 6]) 1573 self.assertEquals("xsd:double", child_types[ 7]) 1574 self.assertEquals("xsd:float", child_types[ 8]) 1575 self.assertEquals("xsd:string", child_types[ 9]) 1576 self.assertEquals("xsd:string", child_types[10]) 1577 self.assertEquals("xsd:float", child_types[11]) 1578 self.assertEquals("xsd:long", child_types[12]) 1579 self.assertEquals(None, child_types[13]) 1580 1581 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1582 1583 for c in root.getiterator(): 1584 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))

1585

1586 - def test_change_pytype_attribute(self):

1587 XML = self.XML 1588 1589 xml = u'''\ 1590 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1591 5 1592 test 1593 <c>1.1</c> 1594 <c>\uF8D2</c> 1595 <x>true</x> 1596 <n xsi:nil="true" /> 1597 <n></n> 1598 5 1599 </a> 1600 ''' 1601 1602 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1603 objectify.setPytypeAttributeTag("{TEST}test") 1604 1605 root = XML(xml) 1606 objectify.annotate(root) 1607 1608 attribs = root.xpath("//@py:%s" % pytype_name, 1609 namespaces={"py" : pytype_ns}) 1610 self.assertEquals(0, len(attribs)) 1611 attribs = root.xpath("//@py:test", 1612 namespaces={"py" : "TEST"}) 1613 self.assertEquals(7, len(attribs)) 1614 1615 objectify.setPytypeAttributeTag() 1616 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1617 1618 self.assertNotEqual("test", pytype_ns.lower()) 1619 self.assertNotEqual("test", pytype_name.lower()) 1620 1621 root = XML(xml) 1622 attribs = root.xpath("//@py:%s" % pytype_name, 1623 namespaces={"py" : pytype_ns}) 1624 self.assertEquals(0, len(attribs)) 1625 1626 objectify.annotate(root) 1627 attribs = root.xpath("//@py:%s" % pytype_name, 1628 namespaces={"py" : pytype_ns}) 1629 self.assertEquals(7, len(attribs))

1630

1631 - def test_registered_types(self):

1632 orig_types = objectify.getRegisteredTypes() 1633 1634 try: 1635 orig_types[0].unregister() 1636 self.assertEquals(orig_types[1:], objectify.getRegisteredTypes()) 1637 1638 class NewType(objectify.ObjectifiedDataElement): 1639 pass

1640 1641 def checkMyType(s): 1642 return True 1643 1644 pytype = objectify.PyType("mytype", checkMyType, NewType) 1645 pytype.register() 1646 self.assert_(pytype in objectify.getRegisteredTypes()) 1647 pytype.unregister() 1648 1649 pytype.register(before = [objectify.getRegisteredTypes()[0].name]) 1650 self.assertEquals(pytype, objectify.getRegisteredTypes()[0]) 1651 pytype.unregister() 1652 1653 pytype.register(after = [objectify.getRegisteredTypes()[0].name]) 1654 self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0]) 1655 pytype.unregister() 1656 1657 self.assertRaises(ValueError, pytype.register, 1658 before = [objectify.getRegisteredTypes()[0].name], 1659 after = [objectify.getRegisteredTypes()[1].name]) 1660 1661 finally: 1662 for pytype in objectify.getRegisteredTypes(): 1663 pytype.unregister() 1664 for pytype in orig_types: 1665 pytype.register() 1666

1667 - def test_object_path(self):

1668 root = self.XML(xml_str) 1669 path = objectify.ObjectPath( "root.c1.c2" ) 1670 self.assertEquals(root.c1.c2.text, path.find(root).text) 1671 self.assertEquals(root.c1.c2.text, path(root).text)

1672

1673 - def test_object_path_list(self):

1674 root = self.XML(xml_str) 1675 path = objectify.ObjectPath( ['root', 'c1', 'c2'] ) 1676 self.assertEquals(root.c1.c2.text, path.find(root).text) 1677 self.assertEquals(root.c1.c2.text, path(root).text)

1678

1679 - def test_object_path_fail(self):

1680 root = self.XML(xml_str) 1681 path = objectify.ObjectPath( "root.c1.c99" ) 1682 self.assertRaises(AttributeError, path, root) 1683 self.assertEquals(None, path(root, None))

1684

1685 - def test_object_path_syntax(self):

1686 root = self.XML(xml_str) 1687 path = objectify.ObjectPath("root . {objectified}c1. c2") 1688 self.assertEquals(root.c1.c2.text, path(root).text) 1689 1690 path = objectify.ObjectPath(" root.{objectified} c1.c2 [ 0 ] ") 1691 self.assertEquals(root.c1.c2.text, path(root).text)

1692

1693 - def test_object_path_hasattr(self):

1694 root = self.XML(xml_str) 1695 path = objectify.ObjectPath( "root" ) 1696 self.assert_(path.hasattr(root)) 1697 path = objectify.ObjectPath( "root.c1" ) 1698 self.assert_(path.hasattr(root)) 1699 path = objectify.ObjectPath( "root.c1.c2" ) 1700 self.assert_(path.hasattr(root)) 1701 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 1702 self.assert_(path.hasattr(root)) 1703 path = objectify.ObjectPath( "root.c1.c2[1]" ) 1704 self.assert_(path.hasattr(root)) 1705 path = objectify.ObjectPath( "root.c1.c2[2]" ) 1706 self.assert_(path.hasattr(root)) 1707 path = objectify.ObjectPath( "root.c1.c2[3]" ) 1708 self.assertFalse(path.hasattr(root)) 1709 path = objectify.ObjectPath( "root.c1[1].c2" ) 1710 self.assertFalse(path.hasattr(root))

1711

1712 - def test_object_path_dot(self):

1713 root = self.XML(xml_str) 1714 path = objectify.ObjectPath( "." ) 1715 self.assertEquals(root.c1.c2.text, path(root).c1.c2.text)

1716

1717 - def test_object_path_dot_list(self):

1718 root = self.XML(xml_str) 1719 path = objectify.ObjectPath( [''] ) 1720 self.assertEquals(root.c1.c2.text, path(root).c1.c2.text)

1721

1722 - def test_object_path_dot_root(self):

1723 root = self.XML(xml_str) 1724 path = objectify.ObjectPath( ".c1.c2" ) 1725 self.assertEquals(root.c1.c2.text, path(root).text)

1726

1727 - def test_object_path_dot_root_list(self):

1728 root = self.XML(xml_str) 1729 path = objectify.ObjectPath( ['', 'c1', 'c2'] ) 1730 self.assertEquals(root.c1.c2.text, path(root).text)

1731

1732 - def test_object_path_index(self):

1733 root = self.XML(xml_str) 1734 path = objectify.ObjectPath( "root.c1[0].c2[0]" ) 1735 self.assertEquals(root.c1.c2.text, path(root).text) 1736 1737 path = objectify.ObjectPath( "root.c1[0].c2" ) 1738 self.assertEquals(root.c1.c2.text, path(root).text) 1739 1740 path = objectify.ObjectPath( "root.c1[0].c2[1]" ) 1741 self.assertEquals(root.c1.c2[1].text, path(root).text) 1742 1743 path = objectify.ObjectPath( "root.c1.c2[2]" ) 1744 self.assertEquals(root.c1.c2[2].text, path(root).text) 1745 1746 path = objectify.ObjectPath( "root.c1.c2[-1]" ) 1747 self.assertEquals(root.c1.c2[-1].text, path(root).text) 1748 1749 path = objectify.ObjectPath( "root.c1.c2[-3]" ) 1750 self.assertEquals(root.c1.c2[-3].text, path(root).text)

1751

1752 - def test_object_path_index_list(self):

1753 root = self.XML(xml_str) 1754 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] ) 1755 self.assertEquals(root.c1.c2.text, path(root).text) 1756 1757 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] ) 1758 self.assertEquals(root.c1.c2[2].text, path(root).text) 1759 1760 path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] ) 1761 self.assertEquals(root.c1.c2[2].text, path(root).text) 1762 1763 path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] ) 1764 self.assertEquals(root.c1.c2[-1].text, path(root).text) 1765 1766 path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] ) 1767 self.assertEquals(root.c1.c2[-3].text, path(root).text)

1768

1769 - def test_object_path_index_fail_parse(self):

1770 self.assertRaises(ValueError, objectify.ObjectPath, 1771 "root.c1[0].c2[-1-2]") 1772 self.assertRaises(ValueError, objectify.ObjectPath, 1773 ['root', 'c1[0]', 'c2[-1-2]']) 1774 1775 self.assertRaises(ValueError, objectify.ObjectPath, 1776 "root[2].c1.c2") 1777 self.assertRaises(ValueError, objectify.ObjectPath, 1778 ['root[2]', 'c1', 'c2']) 1779 1780 self.assertRaises(ValueError, objectify.ObjectPath, 1781 []) 1782 self.assertRaises(ValueError, objectify.ObjectPath, 1783 ['', '', ''])

1784

1785 - def test_object_path_index_fail_lookup(self):

1786 root = self.XML(xml_str) 1787 path = objectify.ObjectPath("root.c1[9999].c2") 1788 self.assertRaises(AttributeError, path, root) 1789 1790 path = objectify.ObjectPath("root.c1[0].c2[9999]") 1791 self.assertRaises(AttributeError, path, root) 1792 1793 path = objectify.ObjectPath(".c1[9999].c2[0]") 1794 self.assertRaises(AttributeError, path, root) 1795 1796 path = objectify.ObjectPath("root.c1[-2].c2") 1797 self.assertRaises(AttributeError, path, root) 1798 1799 path = objectify.ObjectPath("root.c1[0].c2[-4]") 1800 self.assertRaises(AttributeError, path, root)

1801

1802 - def test_object_path_ns(self):

1803 root = self.XML(xml_str) 1804 path = objectify.ObjectPath( "{objectified}root.c1.c2" ) 1805 self.assertEquals(root.c1.c2.text, path.find(root).text) 1806 path = objectify.ObjectPath( "{objectified}root.{objectified}c1.c2" ) 1807 self.assertEquals(root.c1.c2.text, path.find(root).text) 1808 path = objectify.ObjectPath( "root.{objectified}c1.{objectified}c2" ) 1809 self.assertEquals(root.c1.c2.text, path.find(root).text) 1810 path = objectify.ObjectPath( "root.c1.{objectified}c2" ) 1811 self.assertEquals(root.c1.c2.text, path.find(root).text) 1812 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 1813 self.assertEquals(getattr(root.c1, '{otherNS}c2').text, 1814 path.find(root).text)

1815

1816 - def test_object_path_ns_list(self):

1817 root = self.XML(xml_str) 1818 path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] ) 1819 self.assertEquals(root.c1.c2.text, path.find(root).text) 1820 path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] ) 1821 self.assertEquals(root.c1.c2.text, path.find(root).text) 1822 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] ) 1823 self.assertEquals(root.c1.c2.text, path.find(root).text) 1824 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] ) 1825 self.assertEquals(root.c1.c2[2].text, path.find(root).text) 1826 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] ) 1827 self.assertEquals(root.c1.c2.text, path.find(root).text) 1828 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] ) 1829 self.assertEquals(root.c1.c2[2].text, path.find(root).text) 1830 path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] ) 1831 self.assertEquals(getattr(root.c1, '{otherNS}c2').text, 1832 path.find(root).text)

1833

1834 - def test_object_path_set(self):

1835 root = self.XML(xml_str) 1836 path = objectify.ObjectPath( "root.c1.c2" ) 1837 self.assertEquals(root.c1.c2.text, path.find(root).text) 1838 self.assertEquals("1", root.c1.c2[1].text) 1839 1840 new_value = "my new value" 1841 path.setattr(root, new_value) 1842 1843 self.assertEquals(new_value, root.c1.c2.text) 1844 self.assertEquals(new_value, path(root).text) 1845 self.assertEquals("1", root.c1.c2[1].text)

1846

1847 - def test_object_path_set_element(self):

1848 root = self.XML(xml_str) 1849 path = objectify.ObjectPath( "root.c1.c2" ) 1850 self.assertEquals(root.c1.c2.text, path.find(root).text) 1851 self.assertEquals("1", root.c1.c2[1].text) 1852 1853 new_el = self.Element("{objectified}test") 1854 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 1855 path.setattr(root, new_el.sub) 1856 1857 self.assertEquals("ATTR", root.c1.c2.get("myattr")) 1858 self.assertEquals("TEST", root.c1.c2.a.text) 1859 self.assertEquals("TEST", path(root).a.text) 1860 self.assertEquals("1", root.c1.c2[1].text)

1861

1862 - def test_object_path_set_create(self):

1863 root = self.XML(xml_str) 1864 path = objectify.ObjectPath( "root.c1.c99" ) 1865 self.assertRaises(AttributeError, path.find, root) 1866 1867 new_value = "my new value" 1868 path.setattr(root, new_value) 1869 1870 self.assertEquals(1, len(root.c1.c99)) 1871 self.assertEquals(new_value, root.c1.c99.text) 1872 self.assertEquals(new_value, path(root).text)

1873

1874 - def test_object_path_set_create_element(self):

1875 root = self.XML(xml_str) 1876 path = objectify.ObjectPath( "root.c1.c99" ) 1877 self.assertRaises(AttributeError, path.find, root) 1878 1879 new_el = self.Element("{objectified}test") 1880 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 1881 path.setattr(root, new_el.sub) 1882 1883 self.assertEquals(1, len(root.c1.c99)) 1884 self.assertEquals("ATTR", root.c1.c99.get("myattr")) 1885 self.assertEquals("TEST", root.c1.c99.a.text) 1886 self.assertEquals("TEST", path(root).a.text)

1887

1888 - def test_object_path_set_create_list(self):

1889 root = self.XML(xml_str) 1890 path = objectify.ObjectPath( "root.c1.c99" ) 1891 self.assertRaises(AttributeError, path.find, root) 1892 1893 new_el = self.Element("{objectified}test") 1894 new_el.a = ["TEST1", "TEST2"] 1895 new_el.a[0].set("myattr", "ATTR1") 1896 new_el.a[1].set("myattr", "ATTR2") 1897 1898 path.setattr(root, list(new_el.a)) 1899 1900 self.assertEquals(2, len(root.c1.c99)) 1901 self.assertEquals("ATTR1", root.c1.c99[0].get("myattr")) 1902 self.assertEquals("TEST1", root.c1.c99[0].text) 1903 self.assertEquals("ATTR2", root.c1.c99[1].get("myattr")) 1904 self.assertEquals("TEST2", root.c1.c99[1].text) 1905 self.assertEquals("TEST1", path(root).text)

1906

1907 - def test_object_path_addattr(self):

1908 root = self.XML(xml_str) 1909 path = objectify.ObjectPath( "root.c1.c2" ) 1910 self.assertEquals(3, len(root.c1.c2)) 1911 path.addattr(root, "test") 1912 self.assertEquals(4, len(root.c1.c2)) 1913 self.assertEquals(["0", "1", "2", "test"], 1914 [el.text for el in root.c1.c2])

1915

1916 - def test_object_path_addattr_element(self):

1917 root = self.XML(xml_str) 1918 path = objectify.ObjectPath( "root.c1.c2" ) 1919 self.assertEquals(3, len(root.c1.c2)) 1920 1921 new_el = self.Element("{objectified}test") 1922 etree.SubElement(new_el, "{objectified}sub").a = "TEST" 1923 1924 path.addattr(root, new_el.sub) 1925 self.assertEquals(4, len(root.c1.c2)) 1926 self.assertEquals("TEST", root.c1.c2[3].a.text) 1927 self.assertEquals(["0", "1", "2"], 1928 [el.text for el in root.c1.c2[:3]])

1929

1930 - def test_object_path_addattr_create(self):

1931 root = self.XML(xml_str) 1932 path = objectify.ObjectPath( "root.c1.c99" ) 1933 self.assertRaises(AttributeError, path.find, root) 1934 1935 new_value = "my new value" 1936 path.addattr(root, new_value) 1937 1938 self.assertEquals(1, len(root.c1.c99)) 1939 self.assertEquals(new_value, root.c1.c99.text) 1940 self.assertEquals(new_value, path(root).text)

1941

1942 - def test_object_path_addattr_create_element(self):

1943 root = self.XML(xml_str) 1944 path = objectify.ObjectPath( "root.c1.c99" ) 1945 self.assertRaises(AttributeError, path.find, root) 1946 1947 new_el = self.Element("{objectified}test") 1948 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 1949 1950 path.addattr(root, new_el.sub) 1951 self.assertEquals(1, len(root.c1.c99)) 1952 self.assertEquals("TEST", root.c1.c99.a.text) 1953 self.assertEquals("TEST", path(root).a.text) 1954 self.assertEquals("ATTR", root.c1.c99.get("myattr"))

1955

1956 - def test_object_path_addattr_create_list(self):

1957 root = self.XML(xml_str) 1958 path = objectify.ObjectPath( "root.c1.c99" ) 1959 self.assertRaises(AttributeError, path.find, root) 1960 1961 new_el = self.Element("{objectified}test") 1962 new_el.a = ["TEST1", "TEST2"] 1963 1964 self.assertEquals(2, len(new_el.a)) 1965 1966 path.addattr(root, list(new_el.a)) 1967 self.assertEquals(2, len(root.c1.c99)) 1968 self.assertEquals("TEST1", root.c1.c99.text) 1969 self.assertEquals("TEST2", path(root)[1].text)

1970

1971 - def test_descendant_paths(self):

1972 root = self.XML(xml_str) 1973 self.assertEquals( 1974 ['{objectified}root', '{objectified}root.c1', 1975 '{objectified}root.c1.c2', 1976 '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]', 1977 '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'], 1978 root.descendantpaths())

1979

1980 - def test_descendant_paths_child(self):

1981 root = self.XML(xml_str) 1982 self.assertEquals( 1983 ['{objectified}c1', '{objectified}c1.c2', 1984 '{objectified}c1.c2[1]', '{objectified}c1.c2[2]', 1985 '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'], 1986 root.c1.descendantpaths())

1987

1988 - def test_descendant_paths_prefix(self):

1989 root = self.XML(xml_str) 1990 self.assertEquals( 1991 ['root.{objectified}c1', 'root.{objectified}c1.c2', 1992 'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]', 1993 'root.{objectified}c1.{otherNS}c2', 1994 'root.{objectified}c1.{}c2'], 1995 root.c1.descendantpaths('root'))

1996

1997 - def test_pickle(self):

1998 import pickle 1999 2000 root = self.XML(xml_str) 2001 out = StringIO() 2002 pickle.dump(root, out) 2003 2004 new_root = pickle.loads(out.getvalue()) 2005 self.assertEquals( 2006 etree.tostring(new_root), 2007 etree.tostring(root))

2008 2009 # E-Factory tests, need to use sub-elements as root element is always 2010 # type-looked-up as ObjectifiedElement (no annotations)

2011 - def test_efactory_int(self):

2012 E = objectify.E 2013 root = E.root(E.val(23)) 2014 self.assert_(isinstance(root.val, objectify.IntElement))

2015

2016 - def test_efactory_long(self):

2017 E = objectify.E 2018 root = E.root(E.val(23L)) 2019 self.assert_(isinstance(root.val, objectify.LongElement))

2020

2021 - def test_efactory_float(self):

2022 E = objectify.E 2023 root = E.root(E.val(233.23)) 2024 self.assert_(isinstance(root.val, objectify.FloatElement))

2025

2026 - def test_efactory_str(self):

2027 E = objectify.E 2028 root = E.root(E.val("what?")) 2029 self.assert_(isinstance(root.val, objectify.StringElement))

2030

2031 - def test_efactory_unicode(self):

2032 E = objectify.E 2033 root = E.root(E.val(unicode("blöödy häll", encoding="ISO-8859-1"))) 2034 self.assert_(isinstance(root.val, objectify.StringElement))

2035

2036 - def test_efactory_bool(self):

2037 E = objectify.E 2038 root = E.root(E.val(True)) 2039 self.assert_(isinstance(root.val, objectify.BoolElement))

2040

2041 - def test_efactory_none(self):

2042 E = objectify.E 2043 root = E.root(E.val(None)) 2044 self.assert_(isinstance(root.val, objectify.NoneElement))

2045

2046 - def test_efactory_value_concatenation(self):

2047 E = objectify.E 2048 root = E.root(E.val(1, "foo", 2.0, "bar ", True, None)) 2049 self.assert_(isinstance(root.val, objectify.StringElement))

2050

2051 - def test_efactory_attrib(self):

2052 E = objectify.E 2053 root = E.root(foo="bar") 2054 self.assertEquals(root.get("foo"), "bar")

2055

2056 - def test_efactory_nested(self):

2057 E = objectify.E 2058 DataElement = objectify.DataElement 2059 root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1), 2060 DataElement(2.0)) 2061 self.assert_(isinstance(root, objectify.ObjectifiedElement)) 2062 self.assertEquals(root.text, "text") 2063 self.assert_(isinstance(root.sub, objectify.ObjectifiedElement)) 2064 self.assertEquals(root.sub.tail, "tail") 2065 self.assert_(isinstance(root.sub.subsub, objectify.StringElement)) 2066 self.assertEquals(len(root.value), 2) 2067 self.assert_(isinstance(root.value[0], objectify.IntElement)) 2068 self.assert_(isinstance(root.value[1], objectify.FloatElement))

2069

2070 -def test_suite():

2071 suite = unittest.TestSuite() 2072 suite.addTests([unittest.makeSuite(ObjectifyTestCase)]) 2073 suite.addTests( 2074 [doctest.DocFileSuite('../../../doc/objectify.txt')]) 2075 return suite

2076 2077 if __name__ == '__main__': 2078 print 'to test use test.py %s' % __file__ 2079

Source Code for Module lxml.tests.test_objectify