def test_that_parse_generates_empty_dictionary_if_xml_does_not_contain_components_element(self):
root = ET.Element('model')
op = ComponentParser()
op.parse(root)
result = op.components
assert_that(result, is_({}))
def test_that_parse_requires_an_outer_components_element(self):
root = ET.Element('component') #Note the lack of a final 's'
op = ComponentParser()
op.parse(root)
result = op.components
assert_that(result, is_({}))
def test_that_parse_sets_component_names_as_specified(self):
name = 'sample component'
root = ET.Element('components')
ET.SubElement(root, 'component', {'name':name})
op = ComponentParser()
op.parse(root)
result = op.components[name]
assert_that(result.name, is_(name))
def test_that_parse_generates_a_component_if_xml_contains_component_element(self):
root = ET.Element('components')
ET.SubElement(root, 'component', {'name':"don't care"})
op = ComponentParser()
op.parse(root)
result = op.components
assert_that(result, is_not([]))
assert_that(type(result), is_(type(Component)))
def test_that_parse_generates_a_component_including_category_if_specified_with_name(self):
category = 'publication'
name = 'sample component'
root = _component_tree_with_category(category, name)
op = ComponentParser()
op.parse(root)
result = op.components[name]
assert_that(result.category_names, is_not(None))
assert_that(result.category_names, has_item(category))
def test_that_parse_skip_element_and_generates_warning_if_component_has_no_name(self):
root = ET.Element('components')
sample_component = ET.SubElement(root, 'component')
ET.SubElement(sample_component, 'category')
op = ComponentParser()
op.parse(root)
result = op.components
assert_that(result, is_({}))
self.l.check(('root', 'WARNING', "Ignoring component definition with no name"))
def test_that_parse_generates_a_component_with_attributes_if_specified(self):
root = ET.Element('components')
component_name = 'example'
ET.SubElement(root, 'component', { 'name':component_name, 'random':'abc', 'random2':'123'})
op = ComponentParser()
op.parse(root)
result = op.components[component_name]
assert_that(result.attributes, is_not(None))
assert_that(result.attributes, has_entry('name', 'example'))
assert_that(result.attributes, has_entry('random', 'abc'))
assert_that(result.attributes, has_entry('random2', '123'))
def test_that_parse_generates_two_component_if_xml_contains_two_component_elements(self):
root = ET.Element('components')
name1 = "first"
name2 = "second"
ET.SubElement(root, 'component', {'name':name1})
ET.SubElement(root, 'component', {'name':name2})
op = ComponentParser()
op.parse(root)
result = op.components
assert_that(len(result), is_(2))
assert_that(type(result[name1]), is_(type(Component)))
assert_that(type(result[name2]), is_(type(Component)))
def test_that_parse_generates_a_component_including_two_categories_if_two_specified(self):
root = ET.Element('components')
component_name = "example"
sample_component = ET.SubElement(root, 'component', {'name':component_name})
name1 = "publication"
name2 = "enquiry"
ET.SubElement(sample_component, 'category', {'name':name1})
ET.SubElement(sample_component, 'category', {'name':name2})
op = ComponentParser()
op.parse(root)
result = op.components[component_name]
assert_that(result.category_names, is_not(None))
assert_that(result.category_names, has_item(name1))
assert_that(result.category_names, has_item(name2))
def getEquationComponents(self, equation_str):
component_structure_grammar = r"""
entry = component / subscript_definition / lookup_definition
component = name _ subscriptlist? _ "=" _ expression
subscript_definition = name _ ":" _ subscript _ ("," _ subscript)*
lookup_definition = name _ &"(" _ expression # uses lookahead assertion to capture whole group
name = basic_id / escape_group
subscriptlist = '[' _ subscript _ ("," _ subscript)* _ ']'
expression = ~r".*" # expression could be anything, at this point.
subscript = basic_id / escape_group
basic_id = ~r"[a-zA-Z][a-zA-Z0-9_\s]*"
escape_group = "\"" ( "\\\"" / ~r"[^\"]" )* "\""
_ = ~r"[\s\\]*" # whitespace character
"""
# replace any amount of whitespace with a single space
equation_str = equation_str.replace('\\t', ' ')
equation_str = re.sub(r"\s+", ' ', equation_str)
parser = parsimonious.Grammar(component_structure_grammar)
tree = parser.parse(equation_str)
parse_object = ComponentParser(tree)
return {
'real_name': parse_object.real_name,
'subs': parse_object.subscripts,
'expr': parse_object.expression,
'kind': parse_object.kind
}
def __init__(self,
component_parser=ComponentParser(),
backend_parser=BackendParser(),
uses_parser=UsesParser()):
self._uses_parser = uses_parser
self._component_parser = component_parser
self._backend_parser = backend_parser
self._parsers = [component_parser, backend_parser, uses_parser]
def test_that_parse_raises_if_category_has_no_name(self):
'''Allow categories with no name in xml file, just means the element will be skipped'''
root = ET.Element('components')
sample_component = ET.SubElement(root, 'component')
ET.SubElement(sample_component, 'category')
op = ComponentParser()
self.assertRaises(AttributeError, op.parse)
def test_that_resolve_does_not_warn_if_component_list_empty(self):
root = ET.Element('component')
op = ComponentParser()
op.parse(root)
op.resolve([])
assert_that(self.l.__str__(), is_("No logging captured"))
def test_that_resolve_warns_if_category_referenced_which_does_not_exist(self):
category = 'something'
name = 'sample component'
root = _component_tree_with_category(category, name)
op = ComponentParser()
op.parse(root)
op.resolve([])
self.l.check(('root', 'WARNING', "Component '{0}' references undefined category '{1}'".format(name, category)))
def test_that_resolve_does_not_warn_if_all_categories_found(self):
category_name = 'something'
category = MockCategory(category_name)
name = 'sample component'
root = _component_tree_with_category(category_name, name)
op = ComponentParser()
op.parse(root)
op.resolve([category])
assert_that(self.l.__str__(), is_("No logging captured"))
def test_that_resolve_links_to_category(self):
category_name = 'something'
category = MockCategory(category_name)
name = 'sample component'
root = _component_tree_with_category(category_name, name)
op = ComponentParser()
op.parse(root)
op.resolve([category])
result = op.components[name]
assert_that(result.category(category_name), is_(same_instance(category)))
assert_that(category.set_component_was_called, is_(True))
assert_that(category.component, is_(same_instance(result)))
def test_that_empty_dictionary_is_returned_if_no_components_found(self):
op = ComponentParser()
result = op.components
assert_that(result, is_({}))
