def test_add_substitution_attrs(self, mock_find_attribute):
target = ClassFactory.elements(2)
mock_find_attribute.side_effect = [-1, 2]
first_attr = target.attrs[0]
second_attr = target.attrs[1]
first_attr.restrictions.max_occurs = 2
attr_name = first_attr.name
attr_qname = target.source_qname(attr_name)
reference_attrs = AttrFactory.list(2)
self.analyzer.substitutions_index[attr_qname] = reference_attrs
self.analyzer.add_substitution_attrs(target, first_attr)
self.assertEqual(4, len(target.attrs))
self.assertEqual(reference_attrs[0], target.attrs[0])
self.assertIsNot(reference_attrs[0], target.attrs[0])
self.assertEqual(reference_attrs[1], target.attrs[3])
self.assertIsNot(reference_attrs[1], target.attrs[3])
self.assertEqual(2, target.attrs[0].restrictions.max_occurs)
self.assertEqual(2, target.attrs[3].restrictions.max_occurs)
second_attr.wildcard = True
self.analyzer.add_substitution_attrs(target, second_attr)
self.assertEqual(4, len(target.attrs))
self.analyzer.add_substitution_attrs(target, AttrFactory.enumeration())
self.assertEqual(4, len(target.attrs))
def test_process_attribute_default_with_enumeration(self):
target = ClassFactory.create()
attr = AttrFactory.enumeration()
attr.restrictions.max_occurs = 2
attr.fixed = True
self.sanitizer.process_attribute_default(target, attr)
self.assertTrue(attr.fixed)
def test_process(self):
target = ClassFactory.elements(2)
self.processor.process(target)
self.assertEqual(2, len(target.attrs))
target.attrs.append(AttrFactory.enumeration())
self.processor.process(target)
self.assertEqual(1, len(target.attrs))
self.assertTrue(target.attrs[0].is_enumeration)
def test_process(self):
target = ClassFactory.elements(2)
self.processor.process(target)
self.assertEqual(2, len(target.attrs))
self.assertEqual(0, len(target.inner))
target = ClassFactory.enumeration(2)
self.processor.process(target)
self.assertEqual(2, len(target.attrs))
self.assertEqual(0, len(target.inner))
enumerations = list(target.attrs)
target.attrs.append(AttrFactory.element())
self.processor.process(target)
self.assertEqual(1, len(target.attrs))
self.assertEqual(1, len(target.inner))
self.assertEqual(enumerations, target.inner[0].attrs)
target.attrs.append(AttrFactory.enumeration())
self.processor.process(target)
self.assertEqual(1, len(target.attrs))
self.assertEqual(1, len(target.inner))
self.assertEqual(3, len(target.inner[0].attrs))
target.attrs.append(AttrFactory.element())
self.processor.process(target)
self.assertEqual(2, len(target.attrs))
self.assertEqual(1, len(target.inner))
self.assertEqual(3, len(target.inner[0].attrs))
target.attrs.append(AttrFactory.enumeration())
with self.assertRaises(AnalyzerValueError) as cm:
self.processor.process(target)
self.assertEqual("Mixed enumeration with more than one normal field.",
str(cm.exception))
def test_process(self, mock_create_substitutions, mock_process_attribute):
def init_substitutions():
self.processor.substitutions = {}
mock_create_substitutions.side_effect = init_substitutions
target = ClassFactory.create(
attrs=[AttrFactory.enumeration(), AttrFactory.any(), AttrFactory.element(),]
)
self.processor.process(target)
self.processor.process(ClassFactory.create())
mock_process_attribute.assert_called_once_with(target, target.attrs[2])
mock_create_substitutions.assert_called_once()
def test_process(self):
one = AttrFactory.attribute(fixed=True)
one_clone = one.clone()
restrictions = Restrictions(min_occurs=10, max_occurs=15)
two = AttrFactory.element(restrictions=restrictions, fixed=True)
two_clone = two.clone()
two_clone.restrictions.min_occurs = 5
two_clone.restrictions.max_occurs = 5
two_clone_two = two.clone()
two_clone_two.restrictions.min_occurs = 4
two_clone_two.restrictions.max_occurs = 4
three = AttrFactory.element()
four = AttrFactory.enumeration()
four_clone = four.clone()
five = AttrFactory.element()
five_clone = five.clone()
five_clone_two = five.clone()
target = ClassFactory.create(attrs=[
one,
one_clone,
two,
two_clone,
two_clone_two,
three,
four,
four_clone,
five,
five_clone,
five_clone_two,
])
winners = [one, two, three, four, five]
self.processor.process(target)
self.assertEqual(winners, target.attrs)
self.assertTrue(one.fixed)
self.assertIsNone(one.restrictions.min_occurs)
self.assertIsNone(one.restrictions.max_occurs)
self.assertFalse(two.fixed)
self.assertEqual(4, two.restrictions.min_occurs)
self.assertEqual(24, two.restrictions.max_occurs)
self.assertIsNone(three.restrictions.min_occurs)
self.assertIsNone(three.restrictions.max_occurs)
self.assertIsNone(four.restrictions.min_occurs)
self.assertIsNone(four.restrictions.max_occurs)
self.assertEqual(0, five.restrictions.min_occurs)
self.assertEqual(3, five.restrictions.max_occurs)
def test_process_dependency_extension_with_enum_type(
self,
mock_find_dependency,
mock_process_simple_extension,
mock_process_complex_extension,
):
extension = ExtensionFactory.create()
target = ClassFactory.create(extensions=[extension])
source = ClassFactory.create(type=ComplexType)
source.attrs.append(AttrFactory.enumeration())
mock_find_dependency.return_value = source
self.processor.process_extension(target, extension)
self.assertEqual(0, mock_process_complex_extension.call_count)
mock_process_simple_extension.assert_called_once_with(
source, target, extension)
def test_process_attribute_name(self):
attr = AttrFactory.create(name="a")
self.sanitizer.process_attribute_name(attr)
self.assertEqual("a", attr.name)
attr.name = "1"
self.sanitizer.process_attribute_name(attr)
self.assertEqual("value_1", attr.name)
attr.name = "foo_+-bar"
self.sanitizer.process_attribute_name(attr)
self.assertEqual("foo bar", attr.name)
attr.name = "+ - *"
self.sanitizer.process_attribute_name(attr)
self.assertEqual("value", attr.name)
attr = AttrFactory.enumeration(default="-20.55")
self.sanitizer.process_attribute_name(attr)
self.assertEqual("value_minus_-20.55", attr.name)
def test_property_is_enumeration(self):
self.assertTrue(AttrFactory.enumeration().is_enumeration)
self.assertFalse(AttrFactory.element().is_enumeration)