tools/jxml/tests/test_lxml.py

# -*- coding: utf-8 -*-
from __future__ import with_statement

import os.path
import sys
import unittest
from unittest import TestCase

from lxml import etree
from lxml.etree import ElementTree
from lxml.etree import Element
from lxml.etree import SubElement
from lxml.etree import QName


class ElementTreeTest(TestCase):

    def test_etree_parse(self):
        with open('sample.xml') as f:
            et = etree.parse(f)
        et = etree.parse('sample.xml')

    def test_etree_fromstring(self):
        with open('sample.xml') as f:
            text = f.read()
        et = etree.fromstring(text)

    def test_etree_from_file(self):
        with open('sample.xml') as f:
            et = ElementTree(file=f)
        root = et.getroot()
        self.assertEqual('{http://example.tld}document', root.tag)
        self.assertEqual('x', root.prefix)
        self.assertTrue('x' in root.nsmap)

        with open('hello.xml') as f:
            et = ElementTree(file=f)
        root = et.getroot()
        self.assertEqual('hello', root.tag)
        self.assertEqual(None, root.prefix)
        self.assertEqual({}, root.nsmap)

    def test_etree_tostring(self):
        with open('sample.xml') as f:
            et = etree.parse(f)
        etree.tostring(et, encoding='utf-8', xml_declaration=True)
        etree.tostring(et.getroot()[0], encoding='utf-8', xml_declaration=True)

    def test_from_element(self):
        elem = Element('document')
        tree = ElementTree(elem)
        self.assertEqual('document', tree.getroot().tag)

        with open('sample.xml') as f:
            et = ElementTree(file=f)
        root = et.getroot()

        tree = ElementTree(root)
        self.assertEqual(root.base, tree.getroot().base)
        self.assertEqual(et.docinfo.URL, tree.docinfo.URL)

    def test_docinfo(self):
        with open('sample.xml') as f:
            et = etree.parse(f)
        import os.path
        self.assertEqual(os.path.abspath('sample.xml'), et.docinfo.URL)
        self.assertEqual('', et.docinfo.doctype)
        self.assertEqual('utf-8', et.docinfo.encoding)
        self.assertEqual(None, et.docinfo.externalDTD)
        self.assertEqual(None, et.docinfo.internalDTD)
        self.assertEqual(None, et.docinfo.public_id)
        self.assertEqual('document', et.docinfo.root_name)
        self.assertFalse(et.docinfo.standalone)
        self.assertEqual(None, et.docinfo.system_url)
        self.assertEqual('1.0', et.docinfo.xml_version)

        et.docinfo.URL = 'http://example.tld'
        self.assertEqual('http://example.tld', et.docinfo.URL)

    def test_parser(self):
        pass

    def test__copy__(self):
        pass

    def test__deepcopy__(self):
        pass

    def test_setroot(self):
        from lxml.etree import XML
        a = XML('<a />').getroottree()
        b = XML('<b />').getroottree()
        a._setroot(b.getroot())
        self.assertEqual('b', a.getroot().tag)

    def test_find(self):
        pass

    def test_findall(self):
        pass

    def test_findtext(self):
        pass

    def test_getiterator(self):
        pass

    def test_getpath(self):
        pass

    def test_getroot(self):
        with open('sample.xml') as f:
            et = etree.parse(f)
        tree = etree.parse('sample.xml')
        root = tree.getroot()
        self.assertEqual('{http://example.tld}document', root.tag)

    def test_iter(self):
        pass

    def test_iterfind(self):
        pass

    def test_parse(self):
        pass

    def test_relaxng(self):
        pass

    def test_write(self):
        with open('sample.xml') as f:
            tree = etree.parse(f)

        import tempfile
        import os
        fd, name = tempfile.mkstemp()
        try:
            with os.fdopen(fd, 'w') as f:
                tree.write(f)
            with open(name) as f:
                tree2 = etree.parse(f)
        finally:
            os.unlink(name)
        self.assertEqual(tree.getroot().tag, tree2.getroot().tag)

    def test_write_c14n(self):
        pass

    def test_xinclude(self):
        pass

    def test_xmlschema(self):
        pass

    def test_xpath(self):
        with open('sample.xml') as f:
            et = etree.parse(f)
        tree = etree.parse('sample.xml')

        nsmap = dict(x='http://example.tld')

        # element
        result = tree.xpath('//x:paragraph', namespaces=nsmap)
        self.assertEqual(1, len(result))
        self.assertEqual('{http://example.tld}paragraph',
                          result[0].tag)

        # attribute
        result = tree.xpath('@version', namespaces=nsmap)
        self.assertEqual(['1.0'], result)

        # string
        result = tree.xpath('"foo"', namespaces=nsmap)
        self.assertEqual('foo', result)

        # number expression
        result = tree.xpath('1', namespaces=nsmap)
        self.assertEqual(1.0, result)

        result = tree.xpath('"1.0"', namespaces=nsmap)
        # should be string, but alas, it returns a number in jxml
        if sys.platform.startswith('java'):
            self.assertEqual(1.0, result)
        else:
            self.assertEqual('1.0', result)

    def test_xslt(self):
        tree = etree.XML('<hello />').getroottree()
        with open('xsl/import-test.xsl') as f:
            xsl_tree = etree.parse(f)
        result = tree.xslt(xsl_tree)
        self.assertEqual('world', result.getroot().tag)


class ElementTest(TestCase):

    def setUp(self):
        with open('sample.xml') as f:
            self.et = ElementTree(file=f)
        self.root = self.et.getroot()

    def tearDown(self):
        pass

    def test_Element(self):
        elem = Element('document', dict(a='1', b='2'), c='3')
        self.assertEqual('document', elem.tag)
        self.assertEqual(dict(a='1', b='2', c='3'),
                          elem.attrib)

        nsmap = dict(a='http://a.example.tld', c='http://c.example.tld')
        elem = Element('{http://a.example.tld}document',
                       {'{http://a.example.tld}a': '1',
                        '{http://b.example.tld}a': '2',
                        'a': '3'},
                       nsmap)

        self.assertEqual('a', elem.prefix)
        self.assertEqual('{http://a.example.tld}document', elem.tag)
        self.assertEqual(nsmap['a'], elem.nsmap['a'])
        self.assertEqual(nsmap['c'], elem.nsmap['c'])
        self.assertTrue('http://b.example.tld' in elem.nsmap.values())
        self.assertEqual('1', elem.get('{http://a.example.tld}a'))
        self.assertEqual('2', elem.get('{http://b.example.tld}a'))
        self.assertEqual('3', elem.get('a'))

    def test_SubElement(self):
        elem = Element('document')
        child = SubElement(elem, 'paragraph')
        grandchild = SubElement(child, 'span')
        self.assertEqual('paragraph', elem[0].tag)
        self.assertEqual('span', elem[0][0].tag)

    def test_base(self):
        uri = os.path.abspath('sample.xml')
        with open(uri) as f:
            et = etree.parse(f)
        root = et.getroot()
        self.assertEqual(uri, root.base)

    def test_tag(self):
        elem = Element('HwpDoc')
        self.assertEqual('HwpDoc', elem.tag)

        elem = Element('{http://www.w3.org/1999/XSL/Transform}stylesheet')
        self.assertTrue(elem.prefix)
        self.assertEqual('{http://www.w3.org/1999/XSL/Transform}stylesheet', elem.tag)

        elem = Element('{http://www.w3.org/1999/XSL/Transform}stylesheet',
                       nsmap=dict(xsl='http://www.w3.org/1999/XSL/Transform'))
        self.assertEqual('xsl', elem.prefix)
        self.assertEqual('{http://www.w3.org/1999/XSL/Transform}stylesheet', elem.tag)

    def test_nsmap(self):
        self.assertEqual(dict(x='http://example.tld'),
                          self.root.nsmap)
        self.assertEqual(dict(x='http://example.tld',
                               z='http://z.example.tld'),
                          self.root[1].nsmap)

    def test_prefix(self):
        self.assertEqual('x', self.root.prefix)
        self.assertEqual('z', self.root[1].prefix)

    def test_text(self):
        self.assertEqual('text', self.root[0].text)
        self.assertEqual(None, self.root[1].text)

    def test_tail(self):
        self.assertEqual('tail', self.root[0].tail)
        self.assertEqual(None, self.root[0][0].tail)

    def test_attrib(self):
        self.assertEqual({'version': '1.0'},
                          self.root.attrib)
        self.assertEqual({'a': '1',
                           '{http://example.tld}b': '2',
                           '{http://z.example.tld}c': '3'},
                          self.root[1].attrib)

    def test__contains__(self):
        pass

    def test__copy__(self):
        pass

    def test__deepcopy__(self):
        pass

    def test__delitem__(self):
        pass

    def test__getitem__(self):
        paragraph = self.root.__getitem__(0)
        self.assertEqual('{http://example.tld}paragraph', paragraph.tag)
        paragraph = self.root[0]
        self.assertEqual('{http://example.tld}paragraph', paragraph.tag)

        paragraph = self.root.__getitem__(1)
        self.assertEqual('{http://z.example.tld}object', paragraph.tag)
        paragraph = self.root[1]
        self.assertEqual('{http://z.example.tld}object', paragraph.tag)

        child = self.root.__getitem__(-1)
        self.assertEqual('{http://example.tld}third', child.tag)
        child = self.root[-1]
        self.assertEqual('{http://example.tld}third', child.tag)

    def test__iter__(self):
        it = self.root.__iter__()

        paragraph = it.next()
        self.assertEqual('{http://example.tld}paragraph',
                          paragraph.tag)
        self.assertEqual('text', paragraph.text)
        self.assertEqual('tail', paragraph.tail)

        paragraph = it.next()
        self.assertEqual('{http://z.example.tld}object',
                          paragraph.tag)

        child = it.next()
        self.assertEqual('{http://example.tld}third',
                          child.tag)

        self.assertRaises(StopIteration, it.next)

    def test__len__(self):
        self.assertEqual(3, self.root.__len__())
        self.assertEqual(3, len(self.root))

    def test__nonzero__(self):
        pass

    def test__repr__(self):
        pass

    def test__reversed__(self):
        it = self.root.__reversed__()

        child = it.next()
        self.assertEqual('{http://example.tld}third',
                          child.tag)

        paragraph = it.next()
        self.assertEqual('{http://z.example.tld}object',
                          paragraph.tag)

        paragraph = it.next()
        self.assertEqual('{http://example.tld}paragraph',
                          paragraph.tag)
        self.assertEqual('text', paragraph.text)
        self.assertEqual('tail', paragraph.tail)

        self.assertRaises(StopIteration, it.next)

    def test__setitem__(self):
        new_child = Element('new-child')
        self.root.__setitem__(1, new_child)
        self.assertEqual('new-child', self.root[1].tag)

        new_child = Element('new-child2')
        self.assertRaises(IndexError, self.root.__setitem__, 3, new_child)

    def test_addnext(self):
        pass

    def test_addprevious(self):
        pass

    def test_append(self):
        new_child = Element('new-child')
        self.root.append(new_child)

        child = self.root[3]
        self.assertEqual('new-child', child.tag)

    def test_clear(self):
        pass

    def test_extend(self):
        pass

    def test_find(self):
        pass

    def test_findall(self):
        pass

    def test_findtext(self):
        pass

    def test_get(self):
        self.assertEqual(None, self.root.get('nonexists'))
        self.assertEqual('1.0', self.root.get('version'))
        self.assertEqual('1', self.root[1].get('a'))
        self.assertEqual('2', self.root[1].get('{http://example.tld}b'))
        self.assertEqual('3', self.root[1].get('{http://z.example.tld}c'))

    def test_getchildren(self):
        children = self.root.getchildren()

        child = children[0]
        self.assertEqual('{http://example.tld}paragraph',
                          child.tag)
        self.assertEqual('text', child.text)
        self.assertEqual('tail', child.tail)

        child = children[1]
        self.assertEqual('{http://z.example.tld}object',
                          child.tag)

        child = children[2]
        self.assertEqual('{http://example.tld}third',
                          child.tag)

    def test_getiterator(self):
        pass

    def test_getnext(self):
        child = self.root[0]
        child = child.getnext()
        self.assertEqual('{http://z.example.tld}object',
                          child.tag)
        child = child.getnext()
        self.assertEqual('{http://example.tld}third',
                          child.tag)
        child = child.getnext()
        self.assertEqual(None, child)

    def test_getparent(self):
        parent = self.root.getparent()
        self.assertEqual(None, parent)

        for child in self.root:
            parent = child.getparent()
            self.assertEqual('{http://example.tld}document',
                              parent.tag)

    def test_getprevious(self):
        child = self.root[-1]
        self.assertEqual('{http://example.tld}third',
                          child.tag)
        child = child.getprevious()
        self.assertEqual('{http://z.example.tld}object',
                          child.tag)
        child = child.getprevious()
        self.assertEqual('{http://example.tld}paragraph',
                          child.tag)
        child = child.getprevious()
        self.assertEqual(None, child)

    def test_getroottree(self):
        elem = Element('HwpDoc')
        self.assertTrue(elem.getroottree() is not None)

    def test_index(self):
        pass

    def test_insert(self):
        pass

    def test_items(self):
        pass

    def test_iter(self):
        pass

    def test_iterancestors(self):
        span = self.root[0][0]
        it = span.iterancestors()

        parent = it.next()
        self.assertEqual('{http://example.tld}paragraph',
                          parent.tag)

        parent = it.next()
        self.assertEqual('{http://example.tld}document',
                          parent.tag)

        self.assertRaises(StopIteration, it.next)

        # with tags predicate

        it = span.iterancestors('{http://example.tld}document')

        parent = it.next()
        self.assertEqual('{http://example.tld}document',
                          parent.tag)

        self.assertRaises(StopIteration, it.next)

    def test_iterchildren(self):
        pass

    def test_descendants(self):
        pass

    def test_iterfind(self):
        pass

    def test_siblings(self):
        pass

    def test_itertext(self):
        pass

    def test_keys(self):
        self.assertEqual(set(['version']),
                          set(self.root.keys()))
        self.assertEqual(set(['a', '{http://example.tld}b',
                               '{http://z.example.tld}c']),
                          set(self.root[1].keys()))

    def test_makeelement(self):
        pass

    def test_remove(self):
        pass

    def test_replace(self):
        pass

    def test_set(self):
        self.root.set('{http://example.tld}a', '1')
        self.assertEqual('1', self.root.get('{http://example.tld}a'))
        self.root.set('{http://c.example.tld}a', '2')
        self.assertEqual('2', self.root.get('{http://c.example.tld}a'))
        self.root.set('a', '3')
        self.assertEqual('3', self.root.get('a'))

    def test_values(self):
        self.root[1].values()

    def test_xpath(self):
        nsmap = dict(x='http://example.tld')

        # element
        result = self.root.xpath('//x:paragraph', namespaces=nsmap)
        self.assertEqual(1, len(result))
        self.assertEqual('{http://example.tld}paragraph',
                          result[0].tag)

        # attribute
        result = self.root.xpath('@version', namespaces=nsmap)
        self.assertEqual(['1.0'], result)

        # string
        result = self.root.xpath('"foo"', namespaces=nsmap)
        self.assertEqual('foo', result)

        # number expression
        result = self.root.xpath('1', namespaces=nsmap)
        self.assertEqual(1.0, result)

        result = self.root.xpath('"1.0"', namespaces=nsmap)
        # should be string, but alas, it returns a number in jxml
        if sys.platform.startswith('java'):
            self.assertEqual(1.0, result)
        else:
            self.assertEqual('1.0', result)


class QNameTest(TestCase):

    text = '{http://example.tld}document'
    namespace = 'http://example.tld'
    localname = 'document'

    def test_from_text(self):
        qname = QName(self.text)
        self.assertEqual(self.text, qname.text)
        self.assertEqual(self.namespace, qname.namespace)
        self.assertEqual(self.localname, qname.localname)

        qname = QName('document')
        self.assertEqual('document', qname.text)
        self.assertEqual(None, qname.namespace)
        self.assertEqual('document', qname.localname)

    def test_from_nsuri_and_tag(self):
        qname = QName(self.namespace, self.localname)
        self.assertEqual(self.text, qname.text)
        self.assertEqual(self.namespace, qname.namespace)
        self.assertEqual(self.localname, qname.localname)

    def test_from_element(self):
        element = Element(self.text)
        qname = QName(element)
        self.assertEqual(self.text, qname.text)
        self.assertEqual(self.namespace, qname.namespace)
        self.assertEqual(self.localname, qname.localname)


class XPathTest(TestCase):

    def test_xpath(self):
        from lxml.etree import parse
        from lxml.etree import XPath
        with file('sample.xml') as f:
            doc = parse(f)

        nsmap = dict(x='http://example.tld')

        # element
        xpath = XPath('//x:paragraph', namespaces=nsmap)
        result = xpath(doc)
        self.assertEqual(1, len(result))
        self.assertEqual('{http://example.tld}paragraph',
                          result[0].tag)

        # attribute
        xpath = XPath('@version', namespaces=nsmap)
        result = xpath(doc)
        self.assertEqual(['1.0'], result)

        # string
        xpath = XPath('"foo"', namespaces=nsmap)
        result = xpath(doc)
        self.assertEqual('foo', result)

        # number
        xpath = XPath('1', namespaces=nsmap)
        self.assertEqual(1, xpath(doc))

        # string, but alas, it returns a number in jxml
        xpath = XPath('"1.0"', namespaces=nsmap)
        result = xpath(doc)
        if sys.platform.startswith('java'):
            self.assertEqual(1.0, result)
        else:
            self.assertEqual('1.0', result)

        # Boolean
        xpath = XPath('1 = 1', namespaces=nsmap)
        self.assertEqual(True, xpath(doc))


class XSLTTest(TestCase):

    def test_from_element(self):
        with open('xsl/import-test.xsl') as f:
            xsl_tree = etree.parse(f)
        etree.XSLT(xsl_tree.getroot())

    def test_xslt_with_default_parser(self):
        with open('xsl/import-test.xsl') as f:
            xsl_tree = etree.parse(f)
        transform = etree.XSLT(xsl_tree)
        result = transform(etree.XML('<hello />'))
        self.assertEqual('world', result.getroot().tag)

    def test_text_output(self):
        with open('text-output.xsl') as f:
            xsl_tree = etree.parse(f)
        transform = etree.XSLT(xsl_tree)
        result = transform(etree.XML('<hello/>'))
        self.assertEqual(None, result.getroot())
        self.assertEqual(u'world', unicode(result))
        self.assertEqual('world', str(result))


if __name__ == '__main__':
    unittest.main()