Add test cases to test method extraction.

Add test_py2puml_with_methods to test py2puml on class containing methods.
Refactor test_py2puml_with_subdomain by moving expected result to file.

Author: grayfox88

py2puml/asserts.py

@@ -20,6 +20,7 @@ def assert_py2puml_is_stringio(domain_path: str, domain_module: str, expected_co
 def assert_multilines(actual_multilines: List[str], expected_multilines: Iterable[str]):
     line_index = 0
     for line_index, (actual_line, expected_line) in enumerate(zip(actual_multilines, expected_multilines)):
+        # print(actual_line)
         assert actual_line == expected_line, f'actual and expected contents have changed at line {line_index + 1}: {actual_line=}, {expected_line=}'
 
     assert line_index + 1 == len(actual_multilines), f'actual and expected diagrams have {line_index + 1} lines'

py2puml/domain/umlclass.py

@@ -19,5 +19,6 @@ class UmlMethod(object):
 @dataclass
 class UmlClass(UmlItem):
     attributes: List[UmlAttribute]
+    # TODO move to UmlItem?
     methods: List[UmlMethod]
     is_abstract: bool = False

py2puml/inspection/inspectclass.py

@@ -29,10 +29,10 @@ def handle_inheritance_relation(
             )
 
 def inspect_static_attributes(
-    class_type_fqn: str,
-    definition_attrs: List[UmlAttribute],
     class_type: Type,
+    class_type_fqn: str,
     root_module_name: str,
+    domain_items_by_fqn: Dict[str, UmlItem],
     domain_relations: List[UmlRelation]
 ) -> List[UmlAttribute]:
     '''
@@ -46,7 +46,8 @@ def inspect_static_attributes(
         name=class_type.__name__,
         fqn=class_type_fqn,
         attributes=definition_attrs,
-        is_abstract=isabstract(class_type)
+        is_abstract=isabstract(class_type),
+        methods=[]
     )
     domain_items_by_fqn[class_type_fqn] = uml_class
     # investigate_domain_definition(class_type)
@@ -91,49 +92,33 @@ def inspect_static_attributes(
 def inspect_methods(
     definition_methods, class_type,
 ):
-    no_dunder = lambda x: not (x[0].startswith('__') or x[0].endswith('__'))
+    no_dunder = lambda method_name: not (method_name[0].startswith('__') or method_name[0].endswith('__'))
     methods = filter(no_dunder, getmembers(class_type, callable))
     for name, method in methods:
-        signature = signature(method)
+        method_signature = signature(method)
         uml_method = UmlMethod(
             name=name,
-            signature=str(signature),
+            signature=str(method_signature),
         )
         definition_methods.append(uml_method)
 
 
-def handle_class_type(
-    class_type: Type,
-    class_type_fqn: str,
-    domain_items_by_fqn: Dict[str, UmlItem],
-) -> UmlClass:
-    definition_attrs: List[UmlAttribute] = []
-    definition_methods: List[UmlMethod] = []
-    uml_class = UmlClass(
-        name=class_type.__name__,
-        fqn=class_type_fqn,
-        attributes=definition_attrs,
-        methods=definition_methods,
-        is_abstract=isabstract(class_type)
-    )
-    domain_items_by_fqn[class_type_fqn] = uml_class
-    return uml_class
-
 def inspect_class_type(
     class_type: Type,
     class_type_fqn: str,
     root_module_name: str,
     domain_items_by_fqn: Dict[str, UmlItem],
     domain_relations: List[UmlRelation]
 ):
-    uml_class = handle_class_type(class_type, class_type_fqn, domain_items_by_fqn)
-    inspect_static_attributes(
-        class_type_fqn, uml_class.attributes, class_type, root_module_name, domain_relations
+    attributes = inspect_static_attributes(
+        class_type, class_type_fqn, root_module_name,
+        domain_items_by_fqn, domain_relations
     )
-    inspect_methods(uml_class.methods, class_type)
     instance_attributes, compositions = parse_class_constructor(class_type, class_type_fqn, root_module_name)
-    uml_class.attributes.extend(instance_attributes)
+    attributes.extend(instance_attributes)
     domain_relations.extend(compositions.values())
+    
+    inspect_methods(domain_items_by_fqn[class_type_fqn].methods, class_type)
 
     handle_inheritance_relation(class_type, class_type_fqn, root_module_name, domain_relations)
 
@@ -144,12 +129,13 @@ def inspect_dataclass_type(
     domain_items_by_fqn: Dict[str, UmlItem],
     domain_relations: List[UmlRelation]
 ):
-    uml_class = handle_class_type(class_type, class_type_fqn, domain_items_by_fqn)
-    inspect_static_attributes(
-        class_type_fqn, uml_class.attributes, class_type, root_module_name, domain_relations
-    )
-    inspect_methods(uml_class.methods, class_type)
-    for attribute in uml_class.attributes:
+    for attribute in inspect_static_attributes(
+        class_type,
+        class_type_fqn,
+        root_module_name,
+        domain_items_by_fqn,
+        domain_relations
+    ):
         attribute.static = False
 
-    handle_inheritance_relation(class_type, class_type_fqn, root_module_name, domain_relations)
+    handle_inheritance_relation(class_type, class_type_fqn, root_module_name, domain_relations)

tests/asserts/method.py

@@ -0,0 +1,8 @@
+from py2puml.domain.umlclass import UmlMethod
+
+
+def assert_method(method: UmlMethod, expected_name: str, expected_signature: str):
+    assert method.name == expected_name
+    assert method.signature == expected_signature
+    #TODO: add 'is_static' attribute to UmlMethod for static methods
+    #TODO: add 'is_class' attribute to UmlMethod for class methods

tests/modules/withmethods/withmethods.py

@@ -0,0 +1,33 @@
+from typing import List, Tuple
+from math import pi
+
+from tests.modules import withenum
+from tests import modules
+from tests.modules.withenum import TimeUnit
+
+
+class Coordinates:
+    def __init__(self, x: float, y: float):
+        self.x = x
+        self.y = y
+
+
+class Point:
+    PI: float = pi
+    origin = Coordinates(0, 0)
+
+    @staticmethod
+    def from_values(x: int, y: str, u: float, z: List[int]) -> 'Point':
+        return Point(x, y, u, z)
+
+    def get_coordinates(self):
+        return self.x, self.y
+
+    def __init__(self, x: int, y: str, unit: str, u: float, z: List[int]):
+        self.coordinates: Coordinates = Coordinates(x, float(y))
+        # al the different imports of TimeUnit must be handled and result in the same 'short type' to display
+        self.day_unit: withenum.TimeUnit = withenum.TimeUnit.DAYS
+        self.hour_unit: modules.withenum.TimeUnit = modules.withenum.TimeUnit.HOURS
+        self.time_resolution: Tuple[str, withenum.TimeUnit] = 'minute', TimeUnit.MINUTE
+        self.x = x
+        self.y = y

tests/puml_files/with_methods.puml

@@ -0,0 +1,20 @@
+@startuml tests.modules.withmethods
+namespace tests.modules.withmethods.withmethods {}
+class tests.modules.withmethods.withmethods.Coordinates {
+  x: float
+  y: float
+}
+class tests.modules.withmethods.withmethods.Point {
+  PI: float {static}
+  coordinates: Coordinates
+  day_unit: TimeUnit
+  hour_unit: TimeUnit
+  time_resolution: Tuple[str, TimeUnit]
+  x: int
+  y: str
+  from_values(x: int, y: str, u: float, z: List[int]) -> 'Point'
+  get_coordinates(self)
+}
+tests.modules.withmethods.withmethods.Point *-- tests.modules.withmethods.withmethods.Coordinates
+footer Generated by //py2puml//
+@enduml

tests/py2puml/inspection/test_inspectclass.py

@@ -8,6 +8,7 @@
 
 from tests.asserts.attribute import assert_attribute
 from tests.asserts.relation import assert_relation
+from tests.asserts.method import assert_method
 
 
 def test_inspect_module_should_find_static_and_instance_attributes(
@@ -167,3 +168,35 @@ def test_inspect_module_should_handle_compound_types_with_numbers_in_their_name(
     assert len(multicast_umlitem.attributes) == 1, '1 attributes of Multicast must be inspected'
     address_attribute = multicast_umlitem.attributes[0]
     assert_attribute(address_attribute, 'addresses', 'List[IPv6]', expected_staticity=False)
+
+def test_inspect_module_should_find_methods(
+    domain_items_by_fqn: Dict[str, UmlItem], domain_relations: List[UmlRelation]
+):
+    '''
+    Test that methods are detected including static methods
+
+    This test case assumes that the methods will be sorted by type as follow:
+        1a - instance methods (special methods aka "dunder")
+        1b - all other instance methods
+        2 - static methods
+    '''
+
+    inspect_module(
+        import_module('tests.modules.withmethods.withmethods'),
+        'tests.modules.withmethods.withmethods',
+        domain_items_by_fqn, domain_relations
+    )
+
+    # Coordinates UmlClass
+    coordinates_umlitem: UmlClass = domain_items_by_fqn['tests.modules.withmethods.withmethods.Coordinates']
+    assert len(coordinates_umlitem.methods) == 0
+
+    # Point UmlClass
+    point_umlitem: UmlClass = domain_items_by_fqn['tests.modules.withmethods.withmethods.Point']
+    assert len(point_umlitem.methods) == 2
+
+    # FIXME dunder methods are filtered out for now
+    # assert point_umlitem.methods[0].name == '__init__'  # 1a - Instance method (special)
+    assert point_umlitem.methods[0].name == 'from_values'  # 2 - Static method
+    assert point_umlitem.methods[1].name == 'get_coordinates'  # 1b - Instance method (regular)
+    # FIXME: use 'assert_method' once UmlMethod restructured

tests/py2puml/test_py2puml.py

@@ -4,6 +4,9 @@
 from py2puml.asserts import assert_py2puml_is_file_content, assert_py2puml_is_stringio
 
 
+from tests import TESTS_PATH
+
+
 CURRENT_DIR = Path(__file__).parent
 
 def test_py2puml_model_on_py2uml_domain():
@@ -38,5 +41,13 @@ class tests.modules.withsubdomain.withsubdomain.Car {
 footer Generated by //py2puml//
 @enduml
 """
-
     assert_py2puml_is_stringio('tests/modules/withsubdomain/', 'tests.modules.withsubdomain', StringIO(expected))
+
+
+def test_py2puml_with_methods():
+    '''
+    Test py2puml with a class containing methods
+    '''
+    with_methods_diagram_file_path = TESTS_PATH / 'puml_files' / 'with_methods.puml'
+
+    assert_py2puml_is_file_content('tests/modules/withmethods', 'tests.modules.withmethods', with_methods_diagram_file_path)