"""Unit-test suite for `pptx.oxml.simpletypes` module.

The `simpletypes` module contains classes that each define a scalar-type that appears as an XML

attribute.

The term "simple-type", as distinct from "complex-type", is an XML Schema distinction. An XML

attribute value must be a single string, and corresponds to a scalar value, like `bool`, `int`, or

`str`. Complex-types describe _elements_, which can have multiple attributes as well as child

elements.

A simple type corresponds to an `<xsd:simpleType>` definition in the XML schema e.g. `ST_Foobar`.

The `BaseSimpleType` subclass provides data validation and type conversion services for use by

`xmlchemy`.

"""

from __future__ import annotations

import pytest

from pptx.oxml.simpletypes import (

BaseIntType,

BaseSimpleType,

ST_Coordinate,

ST_HexColorRGB,

ST_Percentage,

)

from ..unitutil.mock import instance_mock, method_mock

class DescribeBaseSimpleType(object):

"""Unit-test suite for `pptx.oxml.simpletypes.BaseSimpleType` objects."""

def it_can_convert_an_XML_attribute_value_to_a_python_type(

self, str_value_, py_value_, convert_from_xml_

):

py_value = ST_SimpleType.from_xml(str_value_)

ST_SimpleType.convert_from_xml.assert_called_once_with(str_value_)

assert py_value is py_value_

def it_can_convert_python_value_to_string(self, to_xml_fixture):

SimpleType, py_value_, str_value_ = to_xml_fixture

str_value = SimpleType.to_xml(py_value_)

SimpleType.validate.assert_called_once_with(py_value_)

SimpleType.convert_to_xml.assert_called_once_with(py_value_)

assert str_value is str_value_

def it_can_validate_a_value_as_a_python_int(self, valid_int_fixture):

value, expected_exception = valid_int_fixture

if expected_exception is None:

BaseSimpleType.validate_int(value)

else:

with pytest.raises(expected_exception):

BaseSimpleType.validate_int(value)

def it_can_validate_a_value_as_a_python_string(self, valid_str_fixture):

value, expected_exception = valid_str_fixture

if expected_exception is None:

BaseSimpleType.validate_string(value)

else:

with pytest.raises(expected_exception):

BaseSimpleType.validate_string(value)

# fixtures -------------------------------------------------------

@pytest.fixture

def to_xml_fixture(

self, request, py_value_, str_value_, convert_to_xml_, validate_

):

return ST_SimpleType, py_value_, str_value_

@pytest.fixture(

params=[

(42, None),

(0, None),

(-42, None),

("42", TypeError),

(None, TypeError),

(42.42, TypeError),

]

)

def valid_int_fixture(self, request):

value, expected_exception = request.param

return value, expected_exception

@pytest.fixture(

params=[

("foobar", None),

("", None),

(" foo ", None),

(("foo",), TypeError),

(42, TypeError),

(None, TypeError),

(42.42, TypeError),

]

)

def valid_str_fixture(self, request):

value, expected_exception = request.param

return value, expected_exception

# fixture components ---------------------------------------------

@pytest.fixture

def convert_from_xml_(self, request, py_value_):

return method_mock(

request,

ST_SimpleType,

"convert_from_xml",

autospec=False,

return_value=py_value_,

)

@pytest.fixture

def convert_to_xml_(self, request, str_value_):

return method_mock(

request,

ST_SimpleType,

"convert_to_xml",

autospec=False,

return_value=str_value_,

)

@pytest.fixture

def py_value_(self, request):

return instance_mock(request, int)

@pytest.fixture

def str_value_(self, request):

return instance_mock(request, str)

@pytest.fixture

def validate_(self, request):

return method_mock(request, ST_SimpleType, "validate", autospec=False)

class DescribeBaseIntType(object):

def it_can_convert_a_string_to_an_int(self, from_xml_fixture):

str_value, expected_value, expected_exception = from_xml_fixture

if expected_exception is None:

value = BaseIntType.convert_from_xml(str_value)

assert value == expected_value

else:

with pytest.raises(expected_exception):

BaseIntType.convert_from_xml(str_value)

def it_can_convert_an_int_to_a_string(self, to_xml_fixture):

value, expected_str_value = to_xml_fixture

str_value = BaseIntType.convert_to_xml(value)

assert str_value == expected_str_value

# fixtures -------------------------------------------------------

@pytest.fixture(

params=[

("42", 42, None),

("-42", -42, None),

("-0042", -42, None),

("", None, ValueError),

("foo", None, ValueError),

("42.42", None, ValueError),

("0x0a3", None, ValueError),

(None, None, TypeError),

]

)

def from_xml_fixture(self, request):

str_value, expected_value, expected_exception = request.param

return str_value, expected_value, expected_exception

@pytest.fixture(params=[(42, "42"), (-42, "-42"), (0x2A, "42")])

def to_xml_fixture(self, request):

value, expected_str_value = request.param

return value, expected_str_value

class DescribeST_Coordinate(object):

def it_can_convert_from_ST_UniversalMeasure(self, univ_meas_fixture):

"""

ST_UniversalMeasure allows strings line '-034.56pt'.

"""

str_value, expected_value = univ_meas_fixture

assert ST_Coordinate.convert_from_xml(str_value) == expected_value

# fixtures -------------------------------------------------------

@pytest.fixture(

params=[

("1.2in", 1097280),

("42mm", 1512000),

("0024cm", 8640000),

("-42pt", -533400),

("-036.214pc", -5519014),

("0pi", 0),

]

)

def univ_meas_fixture(self, request):

str_value, expected_value = request.param

return str_value, expected_value

class DescribeST_HexColorRGB(object):

def it_can_validate_a_hex_RGB_string(self, valid_fixture):

str_value, exception = valid_fixture

if exception is None:

try:

ST_HexColorRGB.validate(str_value)

except ValueError: # pragma: no cover

raise AssertionError("string '%s' did not validate" % str_value)

else:

with pytest.raises(exception):

ST_HexColorRGB.validate(str_value)

def it_converts_RGB_string_to_upper_case(self, to_xml_fixture):

value, expected_value = to_xml_fixture

_value = ST_HexColorRGB.convert_to_xml(value)

assert _value == expected_value

# fixtures -------------------------------------------------------

@pytest.fixture(

params=[("deadbf", "DEADBF"), ("012345", "012345"), ("0a1b3c", "0A1B3C")]

)

def to_xml_fixture(self, request):

value, expected_value = request.param

return value, expected_value

@pytest.fixture(

params=[

("012345", None),

("ABCDEF", None),

("deadbf", None),

("0A1B3C", None),

(None, TypeError), # must be string

(123456, TypeError), # must be string

("F00BAR", ValueError), # includes non-hex character 'R'

("F00b", ValueError), # too short, must be 6 characters

]

)

def valid_fixture(self, request):

str_value, exception = request.param

return str_value, exception

class DescribeST_Percentage(object):

def it_can_convert_from_xml_percent_literals(self, percent_fixture):

str_value, expected_value = percent_fixture

value = ST_Percentage.convert_from_xml(str_value)

assert abs(value - expected_value) < 0.000001

# fixtures -------------------------------------------------------

@pytest.fixture(

params=[

("12.34%", 0.1234),

("42%", 0.42),

("024%", 0.24),

("-42%", -0.42),

("-036.214%", -0.36214),

("0%", 0.0),

]

)

def percent_fixture(self, request):

str_value, expected_value = request.param

return str_value, expected_value

# --------------------------------------------------------------------

# static fixture

# --------------------------------------------------------------------

class ST_SimpleType(BaseSimpleType):

@classmethod

def convert_from_xml(cls, str_value):

return 666 # pragma: no cover

@classmethod

def convert_to_xml(cls, value):

return "666" # pragma: no cover

@classmethod

def validate(cls, value):

pass # pragma: no cover