def test_that_resolving_warns_about_missing_category_backend_if_no_includes_found(self):
op = UsesParser()
category = MockCategory()
op.resolve([category], [])
self.l.check(('root', 'WARNING', "Category '{0}' has no backend specified".format(category.catid)))
def test_that_parse_returns_a_uses_if_one_is_specified(self):
root = ET.Element('config')
ET.SubElement(root, 'uses')
op = UsesParser()
op.parse(root)
result = op.uses
assert_that(result, is_not(None))
assert_that(type(result), is_(type(Uses)))
def test_that_parse_ignores_uses_which_dont_reference_a_backend(self):
root = ET.Element('config')
uses = ET.SubElement(root, 'uses')
ET.SubElement(uses, 'use')
op = UsesParser()
op.parse(root)
result = op.uses
assert_that(len(result.uses), is_(0))
def test_that_category_is_added_to_includes_for_backend_if_include_specified_in_use_element(self):
backend = 'db'
category = MockCategory()
root = _build_tree_with_valid_category_include(backend, category)
op = UsesParser()
op.parse(root)
result = op.uses
assert_that(result.backend_for(category.catid), is_(backend))
def test_that_parse_returns_a_uses_including_a_dictionary_of_use_sets_if_at_least_one_is_specified(self):
root = ET.Element('config')
uses = ET.SubElement(root, 'uses')
ET.SubElement(uses, 'use', {'backend':'db'})
op = UsesParser()
op.parse(root)
result = op.uses
assert_that(result.uses, is_not(None))
assert_that(result.uses, has_key('db'))
def test_that_category_is_added_to_included_in_backend_with_include_all_specified(self):
root = ET.Element('config')
uses = ET.SubElement(root, 'uses')
backend = 'db'
use = ET.SubElement(uses, 'use', {'backend':backend})
ET.SubElement(use, 'includeall')
op = UsesParser()
op.parse(root)
result = op.uses
assert_that(result.backend_for('anything'), is_(backend))
def test_that_parsing_two_uses_elements_with_a_category_include_each_includes_both(self):
backend = 'db'
category1 = MockCategory('publication')
category2 = MockCategory('another')
root1 = _build_tree_with_valid_category_include(backend, category1)
root2 = _build_tree_with_valid_category_include(backend, category2)
op = UsesParser()
op.parse(root1)
op.parse(root2)
result = op.uses
assert_that(result.backend_for(category1.catid), is_(backend))
assert_that(result.backend_for(category2.catid), is_(backend))
def test_that_two_uses_in_same_tree_can_both_add_includes(self):
root = ET.Element('config')
backend1 = 'db'
category1 = 'publication'
backend2 = 'cass'
category2 = 'another'
self._add_uses_element(root, backend1, category1)
self._add_uses_element(root, backend2, category2)
op = UsesParser()
op.parse(root)
result = op.uses
assert_that(result.backend_for(category1), is_(backend1))
assert_that(result.backend_for(category2), is_(backend2))
def test_that_excluded_category_overrides_include_all_element(self):
root = ET.Element('config')
uses = ET.SubElement(root, 'uses')
backend = 'db'
use = ET.SubElement(uses, 'use', {'backend':backend})
ET.SubElement(use, 'includeall')
include = ET.SubElement(use, 'exclude')
category = 'publication'
ET.SubElement(include, 'category', {'name':category})
op = UsesParser()
op.parse(root)
result = op.uses
assert_that(result.backend_for(category), is_(None))
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_resolve_warns_if_category_linked_to_nonexistant_backend(self):
backend = 'db'
category = MockCategory()
root = _build_tree_with_valid_category_include(backend, category)
op = UsesParser()
op.parse(root)
op.resolve([category], {})
self.l.check(('root', 'WARNING', "Category '{0}' has link to nonexistant backend {1}".format(category.catid, backend)))
def test_that_resolving_does_not_warn_if_category_missing_backend_but_component_includes_it(self):
backend = 'db'
category = MockCategory()
example_component = Component(categories = [category.catid])
component_name = 'example'
root = _build_tree_with_valid_component_include(backend, component_name)
op = UsesParser()
op.parse(root)
op.resolve([category], {component_name:example_component}, {backend:MockBackend()})
assert_that(self.l.__str__(), is_("No logging captured"))
def test_that_resolve_links_categories_to_backend(self):
backend = 'db'
category = MockCategory()
root = _build_tree_with_valid_category_include(backend, category)
op = UsesParser()
op.parse(root)
example_backend = MockBackend()
op.resolve([category], {}, {backend:example_backend})
assert_that(category.set_backend_called, is_(True))
assert_that(category.backend, is_(same_instance(example_backend)))
def test_that_resolve_links_backends_to_categories(self):
backend_name = 'db'
category = MockCategory()
root = _build_tree_with_valid_category_include(backend_name, category)
op = UsesParser()
op.parse(root)
backend = MockBackend()
op.resolve([category], {}, {backend_name:backend})
assert_that(backend.add_category_called, is_(True))
assert_that(backend.categories, has_item(same_instance(category)))
def test_that_resolving_does_not_warn_if_category_missing_backend_but_include_all_specified(self):
root = ET.Element('config')
uses = ET.SubElement(root, 'uses')
backend = 'db'
use = ET.SubElement(uses, 'use', {'backend':backend})
ET.SubElement(use, 'includeall')
op = UsesParser()
category = MockCategory()
op.parse(root)
op.resolve([category], [], {backend:MockBackend()})
assert_that(self.l.__str__(), is_("No logging captured"))
def test_that_resolve_warns_if_component_include_is_not_in_components_list(self):
component_name = 'nonexistant'
root = ET.Element('config')
uses = ET.SubElement(root, 'uses')
backend = 'db'
use = ET.SubElement(uses, 'use', {'backend':backend})
include = ET.SubElement(use, 'include')
ET.SubElement(include, 'component', {'name':component_name})
op = UsesParser()
op.parse(root)
category_name = "don't care"
op.resolve([MockCategory(category_name)], {})
# TODO We don't care about the second method here. Create a better matcher than l.check to allow checking for only a subset of the messages
self.l.check(('root', 'WARNING', "Component '{0}' is included/excluded for backend {1}, but does not exist".format(component_name, backend)),
('root', 'WARNING', "Category '{0}' has no backend specified".format(category_name)))
def test_that_component_level_exclude_overrides_include_all(self):
category = MockCategory()
example_component = Component(categories = [category.catid])
component_name = 'example'
root = ET.Element('config')
uses = ET.SubElement(root, 'uses')
backend = 'db'
use = ET.SubElement(uses, 'use', {'backend':backend})
ET.SubElement(use, 'includeall')
exclude = ET.SubElement(use, 'exclude')
ET.SubElement(exclude, 'component', {'name':component_name})
op = UsesParser()
op.parse(root)
op.resolve([category], {component_name:example_component})
self.l.check(('root', 'WARNING', "Category '{0}' has no backend specified".format(category.catid)))