def test_some_more_of_a_type(self):
result = dict(
ModuleTypesTools.get_omitted_modules_by_type(
TestPhysicalModuleDescriber(
map=dict({
"A": (
PhysicalModuleTypes.Implementation,
PhysicalModuleTypes.Interface,
PhysicalModuleTypes.Configuration,
),
"B": (
PhysicalModuleTypes.Implementation,
PhysicalModuleTypes.Interface,
PhysicalModuleTypes.Configuration,
)
}),
default=(PhysicalModuleTypes.Framework, )),
DefaultModuleListSupply(modules=[
"B",
"A",
]), AllDependencyFilterConfiguration))
self.assertEquals(
set([
("Implementation", "Interface", "Configuration"),
]), set(result.keys()))
self.assertEquals([("A", 0), ("B", 0)],
sorted(result[("Implementation", "Interface",
"Configuration")]))
def test_null(self):
self.assertEquals([],
sorted(
ModuleTypesTools.get_omitted_modules_by_type(
TestPhysicalModuleDescriber(
map=dict(),
default=PhysicalModuleTypes.Framework),
DefaultModuleListSupply(modules=[]),
AllDependencyFilterConfiguration)))
def _is_legal_dependency(self, source, target):
if not config_module_list_supply.is_external_module(target):
source_types = config_physical_module_describer.get_physical_module_types(source)
target_types = config_physical_module_describer.get_physical_module_types(target)
# TODO Modulgruppen von source und target bestimmen und vergleichen
# und zwar die Ebene bestimmen, auf der sie sich unterscheiden
same_module_group = self.__module_grouper.get_node_group_prefix(source) == self.__module_grouper.get_node_group_prefix(target)
is_legal = any(map(lambda source_type:
ModuleTypesTools.any_in_list(target_types,
self.allowed_target_types(source_type, same_module_group)),
source_types))
self.__logger.debug("%s(%s)->%s(%s):%s", source, PhysicalModuleTypes.names(source_types),
target, PhysicalModuleTypes.names(target_types), is_legal)
return is_legal
else:
self.__logger.info("%s->%s (external)", source, target)
return True
def get_node_color(self, node):
module_types = config_physical_module_describer.get_physical_module_types(node)
module_type = ModuleTypesTools.get_regular_type(module_types)
if module_type == None:
return Colors.PURPLE
else:
# TODO use a map
if module_type in [PhysicalModuleTypes.ImplementationTest, PhysicalModuleTypes.InterfaceTest]:
return Colors.SALMON
elif module_type == PhysicalModuleTypes.Configurator:
return Colors.YELLOW
elif module_type == PhysicalModuleTypes.Configuration:
return Colors.RED
elif module_type in [PhysicalModuleTypes.Interface]:
return Colors.DARKGREEN
elif module_type in [PhysicalModuleTypes.InterfaceUtility]:
return Colors.GREEN
elif module_type in [PhysicalModuleTypes.InterfaceBaseImplementation, PhysicalModuleTypes.InterfaceDefaultImplementation]:
return Colors.GREENYELLOW
elif module_type in [PhysicalModuleTypes.Marshaling, PhysicalModuleTypes.InterfaceWrapper, PhysicalModuleTypes.ImplementationWrapper]:
return Colors.RED
return Colors.WHITE
def _get_omitted_modules_list(self):
grouped_modules = ModuleTypesTools.get_omitted_modules_by_type(
physical_module_describer=config_physical_module_describer,
module_list_supply=config_module_list_supply,
dependency_filter_config_class=config_dependency_filter_config_class
)
grouped_modules = list(grouped_modules)
grouped_formatted_modules = ((", ".join(keyval), ", ".join(
"%s (%i)" % (module, size)
for (module, size
) in sorted(type_modules, key=lambda (module, size): size)))
for (keyval,
type_modules) in grouped_modules
if len(keyval))
return "<ul>%s</ul>" % ("\n".join(
"<li>type <b>%s</b>: %s</li>" % (types, modules)
for (types, modules) in grouped_formatted_modules))
def _get_ungrouped_modules_list(self):
# TODO Das ist eigentlich nicht EPM-spezifisch
return ModuleListHelper.get_ungrouped_modules(
module_list_supply=config_module_list_supply,
module_grouper_class=config_module_grouper_class)
def _write_config_info(self):
print >> self._get_output_file(
), "<p>Configuration information:<br/><ul>"
print >> self._get_output_file(
), "<li>Modules partially or completely omitted from output: %s</li>" % (
self._get_omitted_modules_list(), )
print >> self._get_output_file(
), "<li>Modules without any group: %s</li>" % (", ".join(
sorted(self._get_ungrouped_modules_list())), )
print >> self._get_output_file(), "</ul><hr/>"
def _write_postamble(self):
self._write_config_info()
HTMLGeneratedGraphOverviewWriter._write_postamble(self)
def skip_module_as_source(self, source):
module_types = self.__physical_module_describer.get_physical_module_types(source)
type_skip = ModuleTypesTools.all_in_list(module_types, self.get_skip_module_types_as_source())
return type_skip