def test_option_values(self):
"""test for ancestor, associated and module options"""
handler = DiadefsHandler(Config())
df_h = DiaDefGenerator(Linker(PROJECT), handler)
cl_config = Config()
cl_config.classes = ['Specialization']
cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config))
self.assertEqual((0, 0), df_h._get_levels())
self.assertEqual(False, df_h.module_names)
self.assertEqual((-1, -1), cl_h._get_levels())
self.assertEqual(True, cl_h.module_names)
for hndl in [df_h, cl_h]:
hndl.config.all_ancestors = True
hndl.config.all_associated = True
hndl.config.module_names = True
hndl._set_default_options()
self.assertEqual((-1, -1), hndl._get_levels())
self.assertEqual(True, hndl.module_names)
handler = DiadefsHandler(Config())
df_h = DiaDefGenerator(Linker(PROJECT), handler)
cl_config = Config()
cl_config.classes = ['Specialization']
cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config))
for hndl in [df_h, cl_h]:
hndl.config.show_ancestors = 2
hndl.config.show_associated = 1
hndl.config.module_names = False
hndl._set_default_options()
self.assertEqual((2, 1), hndl._get_levels())
self.assertEqual(False, hndl.module_names)
#def test_default_values(self):
"""test efault values for package or class diagrams"""
def test_option_values(HANDLER, PROJECT):
"""test for ancestor, associated and module options"""
df_h = DiaDefGenerator(Linker(PROJECT), HANDLER)
cl_config = Config()
cl_config.classes = ['Specialization']
cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config) )
assert (0, 0) == df_h._get_levels()
assert False == df_h.module_names
assert (-1, -1) == cl_h._get_levels()
assert True == cl_h.module_names
for hndl in [df_h, cl_h]:
hndl.config.all_ancestors = True
hndl.config.all_associated = True
hndl.config.module_names = True
hndl._set_default_options()
assert (-1, -1) == hndl._get_levels()
assert True == hndl.module_names
handler = DiadefsHandler( Config())
df_h = DiaDefGenerator(Linker(PROJECT), handler)
cl_config = Config()
cl_config.classes = ['Specialization']
cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config) )
for hndl in [df_h, cl_h]:
hndl.config.show_ancestors = 2
hndl.config.show_associated = 1
hndl.config.module_names = False
hndl._set_default_options()
assert (2, 1) == hndl._get_levels()
assert False == hndl.module_names
#def test_default_values():
"""test efault values for package or class diagrams"""
def test_option_values(default_config: PyreverseConfig,
HANDLER: DiadefsHandler, PROJECT: Project) -> None:
"""Test for ancestor, associated and module options."""
df_h = DiaDefGenerator(Linker(PROJECT), HANDLER)
cl_config = default_config
cl_config.classes = ["Specialization"]
cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config))
assert df_h._get_levels() == (0, 0)
assert not df_h.module_names
assert cl_h._get_levels() == (-1, -1)
assert cl_h.module_names
for hndl in (df_h, cl_h):
hndl.config.all_ancestors = True
hndl.config.all_associated = True
hndl.config.module_names = True
hndl._set_default_options()
assert hndl._get_levels() == (-1, -1)
assert hndl.module_names
handler = DiadefsHandler(default_config)
df_h = DiaDefGenerator(Linker(PROJECT), handler)
cl_config = default_config
cl_config.classes = ["Specialization"]
cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config))
for hndl in (df_h, cl_h):
hndl.config.show_ancestors = 2
hndl.config.show_associated = 1
hndl.config.module_names = False
hndl._set_default_options()
assert hndl._get_levels() == (2, 1)
assert not hndl.module_names
def test_option_values(HANDLER, PROJECT):
"""test for ancestor, associated and module options"""
df_h = DiaDefGenerator(Linker(PROJECT), HANDLER)
cl_config = Config()
cl_config.classes = ["Specialization"]
cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config))
assert df_h._get_levels() == (0, 0)
assert not df_h.module_names
assert cl_h._get_levels() == (-1, -1)
assert cl_h.module_names
for hndl in [df_h, cl_h]:
hndl.config.all_ancestors = True
hndl.config.all_associated = True
hndl.config.module_names = True
hndl._set_default_options()
assert hndl._get_levels() == (-1, -1)
assert hndl.module_names
handler = DiadefsHandler(Config())
df_h = DiaDefGenerator(Linker(PROJECT), handler)
cl_config = Config()
cl_config.classes = ["Specialization"]
cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config))
for hndl in [df_h, cl_h]:
hndl.config.show_ancestors = 2
hndl.config.show_associated = 1
hndl.config.module_names = False
hndl._set_default_options()
assert hndl._get_levels() == (2, 1)
assert not hndl.module_names
def test_known_values1(HANDLER: DiadefsHandler, PROJECT: Project) -> None:
dd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)
assert len(dd) == 2
keys = [d.TYPE for d in dd]
assert keys == ["package", "class"]
pd = dd[0]
assert pd.title == "packages No Name"
modules = sorted(
(isinstance(m.node, nodes.Module), m.title) for m in pd.objects)
assert modules == [
(True, "data"),
(True, "data.clientmodule_test"),
(True, "data.property_pattern"),
(True, "data.suppliermodule_test"),
]
cd = dd[1]
assert cd.title == "classes No Name"
classes = _process_classes(cd.objects)
assert classes == [
(True, "Ancestor"),
(True, "CustomException"),
(True, "DoNothing"),
(True, "DoNothing2"),
(True, "DoSomething"),
(True, "Interface"),
(True, "PropertyPatterns"),
(True, "Specialization"),
]
def test_exctract_relations(self, HANDLER: DiadefsHandler,
PROJECT: Project) -> None:
"""Test extract_relations between classes."""
cd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)[1]
cd.extract_relationships()
relations = _process_relations(cd.relationships)
assert relations == self._should_rels
def run(self, args):
"""checking arguments and run project"""
if not args:
print(self.help())
return 1
# insert current working directory to the python path to recognize
# dependencies to local modules even if cwd is not in the PYTHONPATH
sys.path.insert(0, os.getcwd())
try:
project = project_from_files(
args,
project_name=self.config.project,
black_list=self.config.black_list,
)
linker = Linker(project, tag=True)
handler = DiadefsHandler(self.config)
diadefs = handler.get_diadefs(project, linker)
finally:
sys.path.pop(0)
if self.config.output_format == "vcg":
writer.VCGWriter(self.config).write(diadefs)
else:
writer.DotWriter(self.config).write(diadefs)
return 0
def test_known_values2(self):
HANDLER.config.module_names = False
cd = ClassDiadefGenerator(Linker(PROJECT), HANDLER).class_diagram(
PROJECT, 'data.clientmodule_test.Specialization')
self.assertEqual(cd.title, 'data.clientmodule_test.Specialization')
classes = _process_classes(cd.objects)
self.assertEqual(classes, [(True, 'Ancestor'), (True, 'DoNothing'),
(True, 'Specialization')])
def test_regression_dataclasses_inference(HANDLER):
project_path = Path("regrtest_data") / "dataclasses_pyreverse"
path = get_project(str(project_path))
cdg = ClassDiadefGenerator(Linker(path), HANDLER)
special = "regrtest_data.dataclasses_pyreverse.InventoryItem"
cd = cdg.class_diagram(path, special)
assert cd.title == special
def test_property_handling(default_config: PyreverseConfig,
get_project: Callable) -> None:
project = get_project("data.property_pattern")
class_diagram = DefaultDiadefGenerator(
Linker(project), DiadefsHandler(default_config)).visit(project)[0]
obj = class_diagram.classe("PropertyPatterns")
assert len(class_diagram.get_methods(obj.node)) == 0
assert class_diagram.get_attrs(obj.node) == ["prop1", "prop2"]
def setUpClass(cls):
project = get_project(os.path.join(os.path.dirname(__file__), 'data'))
linker = Linker(project)
handler = DiadefsHandler(CONFIG)
dd = DefaultDiadefGenerator(linker, handler).visit(project)
for diagram in dd:
diagram.extract_relationships()
writer = DotWriter(CONFIG)
writer.write(dd)
def test_known_values2(HANDLER, PROJECT):
HANDLER.config.classes = ['Specialization']
HANDLER.config.module_names = False
cd = ClassDiadefGenerator(Linker(PROJECT), HANDLER).class_diagram(PROJECT, 'data.clientmodule_test.Specialization')
assert cd.title == 'data.clientmodule_test.Specialization'
classes = _process_classes(cd.objects)
assert classes == [(True, 'Ancestor'),
(True, 'DoNothing'),
(True, 'Specialization')]
def test_known_values2(self, HANDLER):
project = get_project('data.clientmodule_test')
dd = DefaultDiadefGenerator(Linker(project), HANDLER).visit(project)
assert len(dd) == 1
keys = [d.TYPE for d in dd]
assert keys == ['class']
cd = dd[0]
assert cd.title == 'classes No Name'
classes = _process_classes(cd.objects)
assert classes == [(True, 'Ancestor'), (True, 'Specialization')]
def test_known_values1(HANDLER, PROJECT):
HANDLER.config.classes = ['Specialization']
cdg = ClassDiadefGenerator(Linker(PROJECT), HANDLER)
special = 'data.clientmodule_test.Specialization'
cd = cdg.class_diagram(PROJECT, special)
assert cd.title == special
classes = _process_classes(cd.objects)
assert classes == [(True, 'data.clientmodule_test.Ancestor'),
(True, special),
(True, 'data.suppliermodule_test.DoNothing')]
def setUpClass(cls):
project = get_project(os.path.join(os.path.dirname(__file__), 'data'))
linker = Linker(project)
handler = DiadefsHandler(CONFIG)
cls.dd = DefaultDiadefGenerator(linker, handler).visit(project)
for diagram in cls.dd:
diagram.extract_relationships()
cls.writer = DotWriter(STDOUT_CONFIG)
cls.package_diagram = cls.dd[0]
cls.class_diagram = cls.dd[1]
def test_known_values2(HANDLER):
project = get_project("data.clientmodule_test")
dd = DefaultDiadefGenerator(Linker(project), HANDLER).visit(project)
assert len(dd) == 1
keys = [d.TYPE for d in dd]
assert keys == ["class"]
cd = dd[0]
assert cd.title == "classes No Name"
classes = _process_classes(cd.objects)
assert classes == [(True, "Ancestor"), (True, "Specialization")]
def test_known_values2(self):
project = get_project('data.clientmodule_test')
dd = DefaultDiadefGenerator(Linker(project), HANDLER).visit(project)
self.assertEqual(len(dd), 1)
keys = [d.TYPE for d in dd]
self.assertEqual(keys, ['class'])
cd = dd[0]
self.assertEqual(cd.title, 'classes No Name')
classes = _process_classes(cd.objects)
self.assertEqual(classes, [(True, 'Ancestor'), (True, 'DoNothing'),
(True, 'Specialization')])
def test_functional_relation_extraction(self):
"""functional test of relations extraction;
different classes possibly in different modules"""
# XXX should be catching pyreverse environnement problem but doesn't
# pyreverse doesn't extracts the relations but this test ok
project = get_project("data")
handler = DiadefsHandler(Config())
diadefs = handler.get_diadefs(project, Linker(project, tag=True))
cd = diadefs[1]
relations = _process_relations(cd.relationships)
assert relations == self._should_rels
def test_known_values4(HANDLER, PROJECT):
HANDLER.config.classes = ["Specialization"]
HANDLER.config.module_names = False
cd = ClassDiadefGenerator(Linker(PROJECT), HANDLER).class_diagram(
PROJECT, "data.clientmodule_test.Specialization")
assert cd.title == "data.clientmodule_test.Specialization"
classes = _process_classes(cd.objects)
assert classes == [
(True, "Ancestor"),
(True, "DoNothing"),
(True, "Specialization"),
]
def test_known_values3(HANDLER: DiadefsHandler, PROJECT: Project) -> None:
HANDLER.config.classes = ["Specialization"]
cdg = ClassDiadefGenerator(Linker(PROJECT), HANDLER)
special = "data.clientmodule_test.Specialization"
cd = cdg.class_diagram(PROJECT, special)
assert cd.title == special
classes = _process_classes(cd.objects)
assert classes == [
(True, "data.clientmodule_test.Ancestor"),
(True, special),
(True, "data.suppliermodule_test.DoNothing"),
(True, "data.suppliermodule_test.DoNothing2"),
]
def _setup(project: Project, config: PyreverseConfig,
writer: DiagramWriter) -> Iterator:
linker = Linker(project)
handler = DiadefsHandler(config)
dd = DefaultDiadefGenerator(linker, handler).visit(project)
for diagram in dd:
diagram.extract_relationships()
writer.write(dd)
yield
for fname in (DOT_FILES + COLORIZED_DOT_FILES + VCG_FILES + PUML_FILES +
COLORIZED_PUML_FILES + MMD_FILES + HTML_FILES):
try:
os.remove(fname)
except FileNotFoundError:
continue
def setup():
project = get_project(os.path.join(os.path.dirname(__file__), "data"))
linker = Linker(project)
CONFIG = Config()
handler = DiadefsHandler(CONFIG)
dd = DefaultDiadefGenerator(linker, handler).visit(project)
for diagram in dd:
diagram.extract_relationships()
writer = DotWriter(CONFIG)
writer.write(dd)
yield
for fname in DOT_FILES:
try:
os.remove(fname)
except:
continue
def run(self, args):
"""checking arguments and run project"""
if not args:
print(self.help())
return 1
with fix_import_path(args):
project = project_from_files(
args,
project_name=self.config.project,
black_list=self.config.ignore_list,
)
linker = Linker(project, tag=True)
handler = DiadefsHandler(self.config)
diadefs = handler.get_diadefs(project, linker)
writer.DiagramWriter(self.config).write(diadefs)
return 0
def test_known_values1(self, HANDLER, PROJECT):
dd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)
assert len(dd) == 2
keys = [d.TYPE for d in dd]
assert keys == ['package', 'class']
pd = dd[0]
assert pd.title == 'packages No Name'
modules = sorted([(isinstance(m.node, astroid.Module), m.title)
for m in pd.objects])
assert modules == [(True, 'data'), (True, 'data.clientmodule_test'),
(True, 'data.suppliermodule_test')]
cd = dd[1]
assert cd.title == 'classes No Name'
classes = _process_classes(cd.objects)
assert classes == [(True, 'Ancestor'), (True, 'DoNothing'),
(True, 'Interface'), (True, 'Specialization')]
def test_known_values1(self):
dd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)
self.assertEqual(len(dd), 2)
keys = [d.TYPE for d in dd]
self.assertEqual(keys, ['package', 'class'])
pd = dd[0]
self.assertEqual(pd.title, 'packages No Name')
modules = sorted([(isinstance(m.node, astroid.Module), m.title)
for m in pd.objects])
self.assertEqual(modules, [(True, 'data'),
(True, 'data.clientmodule_test'),
(True, 'data.suppliermodule_test')])
cd = dd[1]
self.assertEqual(cd.title, 'classes No Name')
classes = _process_classes(cd.objects)
self.assertEqual(classes, [(True, 'Ancestor'), (True, 'DoNothing'),
(True, 'Interface'),
(True, 'Specialization')])
def test_known_values1(HANDLER, PROJECT):
dd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)
assert len(dd) == 2
keys = [d.TYPE for d in dd]
assert keys == ["package", "class"]
pd = dd[0]
assert pd.title == "packages No Name"
modules = sorted([(isinstance(m.node, astroid.Module), m.title)
for m in pd.objects])
assert modules == [
(True, "data"),
(True, "data.clientmodule_test"),
(True, "data.suppliermodule_test"),
]
cd = dd[1]
assert cd.title == "classes No Name"
classes = _process_classes(cd.objects)
assert classes == [
(True, "Ancestor"),
(True, "DoNothing"),
(True, "Interface"),
(True, "Specialization"),
]
def test_exctract_relations(self, HANDLER, PROJECT):
"""test extract_relations between classes"""
cd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)[1]
cd.extract_relationships()
relations = _process_relations(cd.relationships)
assert relations == self._should_rels
