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

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/data/with_methods.puml

@@ -0,0 +1,19 @@
+@startuml
+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
+  void __init__(x: int, y: str, unit: str, u: float, z: List[int])
+  (float, float) get_coordinates()
+  {static} Point from_values(x: int, y: str, u: float, z: List[int])
+}
+tests.modules.withmethods.withmethods.Point *-- tests.modules.withmethods.withmethods.Coordinates
+@enduml

tests/data/with_subdomain.puml

@@ -0,0 +1,13 @@
+@startuml
+class tests.modules.withsubdomain.subdomain.insubdomain.Engine {
+  horsepower: int
+}
+class tests.modules.withsubdomain.subdomain.insubdomain.Pilot {
+  name: str
+}
+class tests.modules.withsubdomain.withsubdomain.Car {
+  name: str
+  engine: Engine
+}
+tests.modules.withsubdomain.withsubdomain.Car *-- tests.modules.withsubdomain.subdomain.insubdomain.Engine
+@enduml

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/py2puml/inspection/test_inspectclass.py

@@ -6,12 +6,10 @@
 from py2puml.domain.umlclass import UmlClass, UmlAttribute
 from py2puml.domain.umlrelation import UmlRelation, RelType
 from py2puml.inspection.inspectmodule import inspect_module
-from py2puml.parsing.astvisitors import ConstructorVisitor
-from py2puml.parsing.moduleresolver import ModuleResolver
-from py2puml.parsing.parseclassconstructor import parse_class_constructor
 
 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():
@@ -70,6 +68,7 @@ def test_inspect_module_should_find_static_and_instance_attributes():
         RelType.COMPOSITION
     )
 
+
 def test_inspect_module_should_find_abstract_class():
     domain_items_by_fqn: Dict[str, UmlItem] = {}
     domain_relations: List[UmlRelation] = []
@@ -91,6 +90,7 @@ def test_inspect_module_should_find_abstract_class():
     assert domain_relations[0].source_fqn == 'tests.modules.withabstract.ClassTemplate'
     assert domain_relations[0].target_fqn == 'tests.modules.withabstract.ConcreteClass'
 
+
 def test_inspect_module_parse_class_constructor_should_not_process_inherited_constructor():
     domain_items_by_fqn: Dict[str, UmlItem] = {}
     domain_relations: List[UmlRelation] = []
@@ -127,6 +127,7 @@ def test_inspect_module_parse_class_constructor_should_not_process_inherited_con
     unit_attribute = metric_origin_umlitem.attributes[0]
     assert_attribute(unit_attribute, 'unit', 'str', expected_staticity=True)
 
+
 def test_inspect_module_should_unwrap_decorated_constructor():
     domain_items_by_fqn: Dict[str, UmlItem] = {}
     domain_relations: List[UmlRelation] = []
@@ -148,3 +149,33 @@ def test_inspect_module_should_unwrap_decorated_constructor():
     # PointDecoratedWithoutWrapping UmlClass
     point_without_wrapping_umlitem: UmlClass = domain_items_by_fqn['tests.modules.withwrappedconstructor.PointDecoratedWithoutWrapping']
     assert len(point_without_wrapping_umlitem.attributes) == 0, 'the attributes of the original constructor could not be found, the constructor was not wrapped by the decorator'
+
+
+def test_inspect_module_should_find_methods():
+    """ 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 """
+
+    domain_items_by_fqn: Dict[str, UmlItem] = {}
+    domain_relations: List[UmlRelation] = []
+    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) == 3
+
+    assert point_umlitem.methods[0].name == '__init__'  # 1a - Instance method (special)
+    assert point_umlitem.methods[1].name == 'get_coordinates'  # 1b - Instance method (regular)
+    assert point_umlitem.methods[2].name == 'from_values'  # 2 - Static method
+    # FIXME: use 'assert_method' once UmlMethod restructured

tests/py2puml/test_py2puml.py

@@ -1,10 +1,9 @@
-
 from pathlib import Path
 
-from py2puml.py2puml import py2puml
+from py2puml import py2puml
 
 CURRENT_DIR = Path(__file__).parent
-from py2puml import py2puml
+DATA_DIR = CURRENT_DIR.parent / 'data'
 
 
 def test_py2puml_model_on_py2uml_domain():
@@ -15,26 +14,24 @@ def test_py2puml_model_on_py2uml_domain():
         puml_content = list(py2puml.py2puml('py2puml/domain', 'py2puml.domain'))
         for line_index, (actual_line, expected_line) in enumerate(zip(puml_content, expected_puml_file)):
             assert actual_line == expected_line, f'updated and versionned content {domain_diagram_file_path} in line {line_index} has changed'
-        
+
         assert line_index + 1 == len(puml_content), f'actual and expected diagrams have {line_index + 1} lines'
 
 
 def test_py2puml_with_subdomain():
-    expected = """@startuml
-class tests.modules.withsubdomain.subdomain.insubdomain.Engine {
-  horsepower: int
-}
-class tests.modules.withsubdomain.subdomain.insubdomain.Pilot {
-  name: str
-}
-class tests.modules.withsubdomain.withsubdomain.Car {
-  name: str
-  engine: Engine
-}
-tests.modules.withsubdomain.withsubdomain.Car *-- tests.modules.withsubdomain.subdomain.insubdomain.Engine
-@enduml
-"""
+    with open(DATA_DIR / 'with_subdomain.puml', 'r', encoding='utf-8') as fref:
+        expected_data = fref.read()
     puml_content = py2puml.py2puml(
       'tests/modules/withsubdomain/', 'tests.modules.withsubdomain'
     )
-    assert ''.join(puml_content) == expected
+    actual_data = ''.join(puml_content)
+    assert actual_data == expected_data
+
+
+def test_py2puml_with_methods():
+    """ Test py2puml with a class containing methods """
+    with open(DATA_DIR / 'with_methods.puml', 'r', encoding='utf-8') as fref:
+        expected_data = fref.read()
+    puml_content = py2puml.py2puml('tests/modules/withmethods', 'tests.modules.withmethods')
+    actual_data = ''.join(puml_content)
+    assert actual_data == expected_data