def test_attribute_eval(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertTrue(type(template.attributes["primes"]) is partial)
self.assertTrue(template.attributes["primes"].func is literal_eval)
self.assertEqual((2, 3, 5, 7), template.attributes["primes"]())
def test_process_dependencies_init_attributes(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertEqual(0, len(template.args))
self.assertEqual(0, len(template.keywords))
self.assertEqual(0, len(template.attributes))
def test_attribute_eval(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertTrue(type(template.attributes["primes"]) is partial)
self.assertTrue(template.attributes["primes"].func is literal_eval)
self.assertEqual((2, 3, 5, 7), template.attributes["primes"]())
def test_parse_bytes(self):
# encode document as windows-1252 to force explicit transcoding to utf-8
stream = bytebuf(self._uresource.encode("windows-1252"))
# the default_encoding here is what is used to encode the value - NOT
# the document encoding!
context = XMLContext(stream, default_encoding="utf-8")
self.assertEqual([_u_motleycrue.encode("utf-8")], context["test"].args)
def test_parse_set_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
evaluator = context["test"].args[0]
self.assertTrue(type(evaluator) is Evaluator)
self.assertTrue(evaluator.factory is set)
self.assertEqual([[]], evaluator.args)
def test_process_dependencies_init_attributes(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertEqual(0, len(template.args))
self.assertEqual(0, len(template.keywords))
self.assertEqual(0, len(template.attributes))
def test_parse_set_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
evaluator = context["test"].args[0]
self.assertTrue(type(evaluator) is Evaluator)
self.assertTrue(evaluator.factory is set)
self.assertEqual([[]], evaluator.args)
def test_parse_dict(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
evaluator = context["test"].args[0]
self.assertTrue(type(evaluator) is Evaluator)
self.assertTrue(evaluator.factory is dict)
self.assertEqual(
[[("seventy-nine", 79), (97, "ninety-seven")]], evaluator.args)
def test_attribute_reference_attribute(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertTrue(type(template.attributes["attr1"]) is Reference)
self.assertEqual("ref1", template.attributes["attr1"])
self.assertTrue(type(template.attributes["attr2"]) is Reference)
self.assertEqual("ref2", template.attributes["attr2"])
def test_parse_bytes_encoding_latin1(self):
# encode document as utf-8 to force explicit transcoding to latin1
stream = bytebuf(self._uresource.encode("utf-8"))
# the explicit encoding="latin1" on the <bytes> element overrides this
# default encoding
context = XMLContext(stream, default_encoding="utf-8")
self.assertEqual(
[_u_motleycrue.encode("latin1")], context["test"].args)
def test_parse_bytes(self):
# encode document as windows-1252 to force explicit transcoding to utf-8
stream = bytebuf(self._uresource.encode("windows-1252"))
# the default_encoding here is what is used to encode the value - NOT
# the document encoding!
context = XMLContext(stream, default_encoding="utf-8")
self.assertEqual(
[_u_motleycrue.encode("utf-8")], context["test"].args)
def test_parse_bytes_encoding_latin1(self):
# encode document as utf-8 to force explicit transcoding to latin1
stream = bytebuf(self._uresource.encode("utf-8"))
# the explicit encoding="latin1" on the <bytes> element overrides this
# default encoding
context = XMLContext(stream, default_encoding="utf-8")
self.assertEqual([_u_motleycrue.encode("latin1")],
context["test"].args)
def test_parse_dict(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
evaluator = context["test"].args[0]
self.assertTrue(type(evaluator) is Evaluator)
self.assertTrue(evaluator.factory is dict)
self.assertEqual([[("seventy-nine", 79), (97, "ninety-seven")]],
evaluator.args)
def test_parse_set(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
evaluator = context["test"].args[0]
self.assertTrue(type(evaluator) is Evaluator)
self.assertTrue(evaluator.factory is set)
# the argument to the evaluator factory is itself a sequence (list)
self.assertEqual([[_u_motleycrue, 79, None]], evaluator.args)
def test_attribute_reference_attribute(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertTrue(type(template.attributes["attr1"]) is Reference)
self.assertEqual("ref1", template.attributes["attr1"])
self.assertTrue(type(template.attributes["attr2"]) is Reference)
self.assertEqual("ref2", template.attributes["attr2"])
def test_parse_set(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
evaluator = context["test"].args[0]
self.assertTrue(type(evaluator) is Evaluator)
self.assertTrue(evaluator.factory is set)
# the argument to the evaluator factory is itself a sequence (list)
self.assertEqual([[_u_motleycrue, 79, None]], evaluator.args)
def test_parse_component_explicit(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
component = context["test"]
self.assertTrue(type(component) is Component)
self.assertEqual("explicit.dotted.name", component.dotted_name)
self.assertEqual("singleton", component.strategy)
self.assertEqual("parent", component.parent_id)
self.assertEqual("after_inject", component.after_inject)
self.assertEqual("before_clear", component.before_clear)
def test_arg_eval(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertTrue(type(template.args[0]) is partial)
self.assertTrue(template.args[0].func is literal_eval)
self.assertEqual({"primes": [2, 3, 5, 7]}, template.args[0]())
self.assertTrue(type(template.keywords["kw"]) is partial)
self.assertTrue(template.keywords["kw"].func is literal_eval)
self.assertEqual([None, True, False], template.keywords["kw"]())
def test_parse_component_explicit(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
component = context["test"]
self.assertTrue(type(component) is Component)
self.assertEqual("explicit.dotted.name", component.dotted_name)
self.assertEqual("singleton", component.strategy)
self.assertEqual("parent", component.parent_id)
self.assertEqual("after_inject", component.after_inject)
self.assertEqual("before_clear", component.before_clear)
def test_arg_eval(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertTrue(type(template.args[0]) is partial)
self.assertTrue(template.args[0].func is literal_eval)
self.assertEqual({"primes": [2, 3, 5, 7]}, template.args[0]())
self.assertTrue(type(template.keywords["kw"]) is partial)
self.assertTrue(template.keywords["kw"].func is literal_eval)
self.assertEqual([None, True, False], template.keywords["kw"]())
def test_parse_dict_nested_eval(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
evaluator = context["test"].args[0]
self.assertTrue(type(evaluator) is Evaluator)
self.assertTrue(evaluator.factory is dict)
# evaluator args is itself a sequence; Aglyph uses list-of-tuples for
# the keys and values
self.assertTrue(type(evaluator.args[0][0][0]) is partial)
self.assertTrue(type(evaluator.args[0][1][1]) is partial)
self.assertEqual({"seven": 7, 9: "nine"}, evaluator(None))
def test_parse_dict_nested_eval(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
evaluator = context["test"].args[0]
self.assertTrue(type(evaluator) is Evaluator)
self.assertTrue(evaluator.factory is dict)
# evaluator args is itself a sequence; Aglyph uses list-of-tuples for
# the keys and values
self.assertTrue(type(evaluator.args[0][0][0]) is partial)
self.assertTrue(type(evaluator.args[0][1][1]) is partial)
self.assertEqual({"seven": 7, 9: "nine"}, evaluator(None))
def test_arg_reference_attribute(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertTrue(type(template.args[0]) is Reference)
self.assertEqual("ref1", template.args[0])
self.assertTrue(type(template.args[1]) is Reference)
self.assertEqual("ref2", template.args[1])
self.assertTrue(type(template.keywords["kw1"]) is Reference)
self.assertEqual("ref3", template.keywords["kw1"])
self.assertTrue(type(template.keywords["kw2"]) is Reference)
self.assertEqual("ref4", template.keywords["kw2"])
def test_parse_set_nested_eval(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
evaluator = context["test"].args[0]
self.assertTrue(type(evaluator) is Evaluator)
self.assertTrue(evaluator.factory is set)
# the argument to the evaluator factory is itself a sequence (list)
self.assertEqual(1, len(evaluator.args))
for p in evaluator.args[0]:
self.assertTrue(type(p) is partial)
self.assertTrue(p.func is literal_eval)
self.assertEqual(set([79, True, "test"]), evaluator(None))
def test_parse_template(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertTrue(type(template) is Template)
self.assertEqual("parent", template.parent_id)
self.assertEqual("after_inject", template.after_inject)
self.assertEqual("before_clear", template.before_clear)
self.assertEqual([], template.args)
self.assertEqual({}, template.keywords)
self.assertTrue(type(template.attributes) is OrderedDict)
self.assertEqual(OrderedDict(), template.attributes)
def test_parse_set_nested_eval(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
evaluator = context["test"].args[0]
self.assertTrue(type(evaluator) is Evaluator)
self.assertTrue(evaluator.factory is set)
# the argument to the evaluator factory is itself a sequence (list)
self.assertEqual(1, len(evaluator.args))
for p in evaluator.args[0]:
self.assertTrue(type(p) is partial)
self.assertTrue(p.func is literal_eval)
self.assertEqual(set([79, True, "test"]), evaluator(None))
def test_parse_template(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertTrue(type(template) is Template)
self.assertEqual("parent", template.parent_id)
self.assertEqual("after_inject", template.after_inject)
self.assertEqual("before_clear", template.before_clear)
self.assertEqual([], template.args)
self.assertEqual({}, template.keywords)
self.assertTrue(type(template.attributes) is OrderedDict)
self.assertEqual(OrderedDict(), template.attributes)
def test_arg_reference_attribute(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
template = context["test"]
self.assertTrue(type(template.args[0]) is Reference)
self.assertEqual("ref1", template.args[0])
self.assertTrue(type(template.args[1]) is Reference)
self.assertEqual("ref2", template.args[1])
self.assertTrue(type(template.keywords["kw1"]) is Reference)
self.assertEqual("ref3", template.keywords["kw1"])
self.assertTrue(type(template.keywords["kw2"]) is Reference)
self.assertEqual("ref4", template.keywords["kw2"])
def test_template_id_is_required(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = ValueError("Template unique ID must not be None or empty")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_context_id_cannot_be_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError("XMLContext ID must not be None or empty")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_parse_int_long(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
self.assertTrue(type(context["test"].args[0]) is long)
self.assertEqual([2**64], context["test"].args)
def test_parse_float_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
self.assertEqual([0.0], context["test"].args)
def test_attribute_rejects_multiple_children(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError(
"<attribute> must contain exactly one child element; "
"found attribute/str, attribute/int")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_context_can_be_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
self.assertEqual(0, len(context))
def test_parse_dict_item_unexpected_children(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError(
"expected item/key, item/value; found item/unexpected")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_process_attributes_attribute(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
self.assertEqual({"attr": 79}, context["test"].attributes)
def test_attribute_name_cannot_be_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError(
"attribute/@name is required and cannot be empty")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_attribute_cannot_be_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError(
"<attribute> must contain exactly one child element; "
"found no children")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_attribute_rejects_multiple_children(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError(
"<attribute> must contain exactly one child element; "
"found attribute/str, attribute/int")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_template_id_is_required(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = ValueError(
"Template unique ID must not be None or empty")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_can_read_from_stream(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
self.assertEqual("test_can_read_from_stream", context.context_id)
def test_process_attributes_unexpected_children(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError("unexpected element: attributes/unexpected")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_dict_item_key_rejects_multiple_children(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError(
"<key> must contain exactly one child element; "
"found key/str, key/int")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_attribute_name_cannot_be_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError(
"attribute/@name is required and cannot be empty")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_parse_int_long(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
self.assertTrue(type(context["test"].args[0]) is long)
self.assertEqual([2**64], context["test"].args)
def test_context_id_cannot_be_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError("XMLContext ID must not be None or empty")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_process_attributes_attribute(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
self.assertEqual({"attr": 79}, context["test"].attributes)
def test_parse_float_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
self.assertEqual([0.0], context["test"].args)
def test_attribute_cannot_be_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError(
"<attribute> must contain exactly one child element; "
"found no children")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_parse_tuple_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
# no Evaluator for empty tuples (they're immutable)
self.assertEqual([tuple()], context["test"].args)
def test_parse_tuple_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
# no Evaluator for empty tuples (they're immutable)
self.assertEqual([tuple()], context["test"].args)
def test_process_attributes_unexpected_children(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError("unexpected element: attributes/unexpected")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_parse_component_implicit(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
component = context["implicit.dotted.name"]
self.assertTrue(type(component) is Component)
self.assertEqual("implicit.dotted.name", component.dotted_name)
def test_parse_dict_item_unexpected_children(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError(
"expected item/key, item/value; found item/unexpected")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_can_read_from_stream(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
self.assertEqual("test_can_read_from_stream", context.context_id)
def test_dict_item_key_rejects_multiple_children(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError(
"<key> must contain exactly one child element; "
"found key/str, key/int")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_context_can_be_empty(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
self.assertEqual(0, len(context))
def test_dict_item_value_unexpected_children(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError("unexpected element: value/unexpected")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_dict_item_value_unexpected_children(self):
stream = bytebuf(self._uresource.encode("utf-8"))
e_expected = AglyphError("unexpected element: value/unexpected")
assertRaisesWithMessage(self, e_expected, XMLContext, stream)
def test_parse_component_implicit(self):
stream = bytebuf(self._uresource.encode("utf-8"))
context = XMLContext(stream)
component = context["implicit.dotted.name"]
self.assertTrue(type(component) is Component)
self.assertEqual("implicit.dotted.name", component.dotted_name)
