from __future__ import absolute_import
#copyright openpyxl 2010-2015
from openpyxl.xml.functions import tostring, fromstring
from openpyxl.tests.helper import compare_xml
from ..serialisable import Serialisable
import pytest
@pytest.fixture
[docs]def NestedValue():
from ..nested import NestedValue
class Simple(Serialisable):
tagname = "simple"
size = NestedValue(expected_type=int)
def __init__(self, size):
self.size = size
return Simple
[docs]class TestValue:
[docs] def test_to_tree(self, NestedValue):
simple = NestedValue(4)
assert simple.size == 4
xml = tostring(NestedValue.size.to_tree("size", simple.size))
expected = """
<size val="4"></size>
"""
diff = compare_xml(xml, expected)
assert diff is None, diff
[docs] def test_from_tree(self, NestedValue):
xml = """
<size val="4"></size>
"""
node = fromstring(xml)
simple = NestedValue(size=node)
assert simple.size == 4
[docs] def test_tag_mismatch(self, NestedValue):
xml = """
<length val="4"></length>
"""
node = fromstring(xml)
with pytest.raises(ValueError):
simple = NestedValue(size=node)
[docs] def test_nested_to_tree(self, NestedValue):
simple = NestedValue(4)
xml = tostring(simple.to_tree())
expected = """
<simple>
<size val="4"/>
</simple>
"""
diff = compare_xml(xml, expected)
assert diff is None, diff
[docs] def test_nested_from_tree(self, NestedValue):
xml = """
<simple>
<size val="4"/>
</simple>
"""
node = fromstring(xml)
obj = NestedValue.from_tree(node)
assert obj.size == 4
@pytest.fixture
[docs]def NestedText():
from ..nested import NestedText
class Simple(Serialisable):
tagname = "simple"
coord = NestedText(expected_type=int)
def __init__(self, coord):
self.coord = coord
return Simple
[docs]class TestText:
[docs] def test_to_tree(self, NestedText):
simple = NestedText(4)
assert simple.coord == 4
xml = tostring(NestedText.coord.to_tree("coord", simple.coord))
expected = """
<coord>4</coord>
"""
diff = compare_xml(xml, expected)
assert diff is None, diff
[docs] def test_from_tree(self, NestedText):
xml = """
<coord>4</coord>
"""
node = fromstring(xml)
simple = NestedText(node)
assert simple.coord == 4
[docs] def test_nested_to_tree(self, NestedText):
simple = NestedText(4)
xml = tostring(simple.to_tree())
expected = """
<simple>
<coord>4</coord>
</simple>
"""
diff = compare_xml(xml, expected)
assert diff is None, diff
[docs] def test_nested_from_tree(self, NestedText):
xml = """
<simple>
<coord>4</coord>
</simple>
"""
node = fromstring(xml)
obj = NestedText.from_tree(node)
assert obj.coord == 4
[docs]def test_bool_value():
from ..nested import NestedBool
class Simple(Serialisable):
bold = NestedBool()
def __init__(self, bold):
self.bold = bold
xml = """
<font>
<bold val="true"/>
</font>
"""
node = fromstring(xml)
simple = Simple.from_tree(node)
assert simple.bold is True
[docs]def test_noneset_value():
from ..nested import NestedNoneSet
class Simple(Serialisable):
underline = NestedNoneSet(values=('1', '2', '3'))
def __init__(self, underline):
self.underline = underline
xml = """
<font>
<underline val="1" />
</font>
"""
node = fromstring(xml)
simple = Simple.from_tree(node)
assert simple.underline == '1'
[docs]def test_min_max_value():
from ..nested import NestedMinMax
class Simple(Serialisable):
size = NestedMinMax(min=5, max=10)
def __init__(self, size):
self.size = size
xml = """
<font>
<size val="6"/>
</font>
"""
node = fromstring(xml)
simple = Simple.from_tree(node)
assert simple.size == 6
[docs]def test_nested_integer():
from ..nested import NestedInteger
class Simple(Serialisable):
tagname = "font"
size = NestedInteger()
def __init__(self, size):
self.size = size
simple = Simple('4')
assert simple.size == 4
[docs]def test_nested_float():
from ..nested import NestedFloat
class Simple(Serialisable):
tagname = "font"
size = NestedFloat()
def __init__(self, size):
self.size = size
simple = Simple('4.5')
assert simple.size == 4.5
[docs]def test_nested_string():
from ..nested import NestedString
class Simple(Serialisable):
tagname = "font"
name = NestedString()
def __init__(self, name):
self.name = name
simple = Simple('4')
assert simple.name == '4'
@pytest.fixture
[docs]def Empty():
from ..nested import EmptyTag
class Simple(Serialisable):
tagname = "break"
height = EmptyTag()
def __init__(self, height=None):
self.height = height
return Simple
[docs]class TestEmptyTag:
@pytest.mark.parametrize("value, result",
[
(False, False),
(True, True),
(None, False),
(1, True)
]
)
[docs] def test_ctor(self, Empty, value, result):
obj = Empty(value)
assert obj.height is result
@pytest.mark.parametrize("value, result",
[
(False, "<break />"),
(True, "<break><height /></break>")
]
)
[docs] def test_to_tree(self, Empty, value, result):
obj = Empty(height=value)
xml = tostring(obj.to_tree())
diff = compare_xml(xml, result)
assert diff is None, diff
@pytest.mark.parametrize("value, src",
[
(False, "<break />"),
(True, "<break><height /></break>")
]
)
[docs] def test_from_xml(self, Empty, value, src):
node = fromstring(src)
obj = Empty.from_tree(node)
assert obj.height is value
@pytest.fixture
[docs]def CustomAttribute():
from ..nested import NestedValue
class Simple(Serialisable):
tagname = "simple"
size = NestedValue(expected_type=int, attribute="something")
def __init__(self, size):
self.size = size
return Simple
[docs]class TestCustomAttribute:
[docs] def test_to_tree(self, CustomAttribute):
simple = CustomAttribute(4)
assert simple.size == 4
xml = tostring(CustomAttribute.size.to_tree("size", simple.size))
expected = """
<size something="4"></size>
"""
diff = compare_xml(xml, expected)
assert diff is None, diff
[docs] def test_from_tree(self, CustomAttribute):
xml = """
<size something="4"></size>
"""
node = fromstring(xml)
simple = CustomAttribute(size=node)
assert simple.size == 4