modelverse/integration/test_mvc.py

import unittest

from utils import *
import sys

sys.path.append("wrappers")
from modelverse import *

expected_model_list = set([("SimpleClassDiagrams", "SimpleClassDiagrams"),
                           ("CoreFormalism", "SimpleClassDiagrams"),
                           ("ManualOperation", "SimpleClassDiagrams"),
                           ("ActionLanguage", "SimpleClassDiagrams"),
                           ("ProcessModel", "SimpleClassDiagrams"),
                           ("Tracability", "SimpleClassDiagrams"),
                           ("conformance_mv", "ActionLanguage"),
                           ("bottom", "SimpleClassDiagrams"),
                           ("core", "CoreFormalism"),
                           ('TypeMapping', 'SimpleClassDiagrams'),
                           ('TM_SimpleClassDiagrams', 'TypeMapping'),
                           ('TM_TypeMapping', 'TypeMapping'),
                           ('TM_Tracability', 'TypeMapping'),
                           ('TM_ProcessModel', 'TypeMapping'),
                           ('TM_ActionLanguage', 'TypeMapping'),
                           ('TM_ManualOperation', 'TypeMapping'),
                           ('TM_conformance_mv', 'TypeMapping'),
                           ('TM_CoreFormalism', 'TypeMapping'),
                           ('TM_core', 'TypeMapping'),
                           ('TM_bottom', 'TypeMapping'),
                          ])

expected_model_full_list = set([("SimpleClassDiagrams", "SimpleClassDiagrams", "admin", "admin", "221"),
                                ("CoreFormalism", "SimpleClassDiagrams", "admin", "admin", "221"),
                                ("ManualOperation", "SimpleClassDiagrams", "admin", "admin", "221"),
                                ("ActionLanguage", "SimpleClassDiagrams", "admin", "admin", "221"),
                                ("ProcessModel", "SimpleClassDiagrams", "admin", "admin", "221"),
                                ("Tracability", "SimpleClassDiagrams", "admin", "admin", "221"),
                                ("bottom", "SimpleClassDiagrams", "admin", "admin", "221"),
                                ("conformance_mv", "ActionLanguage", "admin", "admin", "221"),
                                ("core", "CoreFormalism", "admin", "admin", "220"),
                                ('TypeMapping', 'SimpleClassDiagrams', "admin", "admin", "221"),
                                ('TM_SimpleClassDiagrams', 'TypeMapping', "admin", "admin", "221"),
                                ('TM_TypeMapping', 'TypeMapping', "admin", "admin", "221"),
                                ('TM_Tracability', 'TypeMapping', "admin", "admin", "221"),
                                ('TM_ProcessModel', 'TypeMapping', "admin", "admin", "221"),
                                ('TM_ActionLanguage', 'TypeMapping', "admin", "admin", "221"),
                                ('TM_ManualOperation', 'TypeMapping', "admin", "admin", "221"),
                                ('TM_conformance_mv', 'TypeMapping', "admin", "admin", "221"),
                                ('TM_CoreFormalism', 'TypeMapping', "admin", "admin", "221"),
                                ('TM_core', 'TypeMapping', "admin", "admin", "220"),
                                ('TM_bottom', 'TypeMapping', "admin", "admin", "221"),
                                ])

expected_transformation_list = set([("ActionLanguage", "conformance_mv")])

class TestModelverseCore(unittest.TestCase):
    def setUp(self):
        self.proc, self.address = start_mvc()
        init(self.address)
        login("admin", "admin")

    def tearDown(self):
        try:
            kill(self.proc)
        except:
            print("Got exception during teardown.")

    def test_list(self):
        assert model_list() == expected_model_list
        
    def test_list_full(self):
        assert model_list_full() == expected_model_full_list

    def test_model_add_empty(self):
        model_add("Empty", "SimpleClassDiagrams")
        assert model_list() == set(list(expected_model_list) + [("Empty", "SimpleClassDiagrams"), ("TM_Empty", "TypeMapping")])
        assert model_list_full() == set(list(expected_model_full_list) + [("Empty", "SimpleClassDiagrams", "admin", "nobody", "200"),
                                                                          ("TM_Empty", "TypeMapping", "admin", "nobody", "200"),
                                                                         ])

    def test_model_verify(self):
        assert verify("SimpleClassDiagrams", "SimpleClassDiagrams") == "OK"

    def test_model_empty_instantiate(self):
        model_add("Empty", "SimpleClassDiagrams")
        assert model_list() == set(list(expected_model_list) + [("Empty", "SimpleClassDiagrams"), ("TM_Empty", "TypeMapping")])
        assert element_list("Empty") == set([])
        instantiate("Empty", "Class", ID="A")
        assert element_list("Empty") == set([("A", "Class")])
        assert model_list() == set(list(expected_model_list) + [("Empty", "SimpleClassDiagrams"), ("TM_Empty", "TypeMapping")])

    def test_model_overwrite(self):
        model_add("Empty", "SimpleClassDiagrams")
        assert model_list() == set(list(expected_model_list) + [("Empty", "SimpleClassDiagrams"), ("TM_Empty", "TypeMapping")])
        assert element_list("Empty") == set([])
        instantiate("Empty", "Class", ID="A")
        assert element_list("Empty") == set([("A", "Class")])
        model_overwrite("Empty")
        assert element_list("Empty") == set([])
        assert model_list() == set(list(expected_model_list) + [("Empty", "SimpleClassDiagrams"), ("TM_Empty", "TypeMapping")])
        instantiate("Empty", "Class", ID="B")
        assert element_list("Empty") == set([("B", "Class")])

    def test_transform_add_MT(self):
        model_add("PetriNet", "SimpleClassDiagrams", open("integration/code/petrinets.mvc", "r").read())
        assert model_list() == set(list(expected_model_list) + [("PetriNet", "SimpleClassDiagrams"),
                                                                ("TM_PetriNet", "TypeMapping"),
                                                               ])
        transformation_add_MT({"PetriNet": "PetriNet"}, {}, "print_pn", open("integration/code/pn_print.mvc").read())
        assert model_list() == set(list(expected_model_list) + [("PetriNet", "SimpleClassDiagrams"),
                                                                ("TM_PetriNet", "TypeMapping"),
                                                                ("__RAM_print_pn", "SimpleClassDiagrams"),
                                                                ("TM___RAM_print_pn", "TypeMapping"),
                                                                ("__merged_print_pn", "SimpleClassDiagrams"),
                                                                ("TM___merged_print_pn", "TypeMapping"),
                                                                ("print_pn", "__RAM_print_pn"),
                                                                ("TM_print_pn", "TypeMapping")])
        assert transformation_list() == set(list(expected_transformation_list) + [("ModelTransformation", "print_pn")])

    def test_transform_add_MT_pn_print_exec(self):
        log = []

        def callback(value):
            log.append(value)

        model_add("PetriNet", "SimpleClassDiagrams", open("integration/code/pn_runtime.mvc", "r").read())
        model_add("my_pn", "PetriNet", open("integration/code/pn_runtime_model.mvc", "r").read())
        assert model_list() == set(list(expected_model_list) + [("PetriNet", "SimpleClassDiagrams"),
                                                                ("TM_PetriNet", "TypeMapping"),
                                                                ("my_pn", "PetriNet"),
                                                                ("TM_my_pn", "TypeMapping"),
                                                               ])
        transformation_add_MT({"PetriNet": "PetriNet"}, {}, "print_pn", open("integration/code/pn_print.mvc").read())
        assert model_list() == set(list(expected_model_list) + [("PetriNet", "SimpleClassDiagrams"),
                                                                ("TM_PetriNet", "TypeMapping"),
                                                                ("my_pn", "PetriNet"),
                                                                ("TM_my_pn", "TypeMapping"),
                                                                ("__RAM_print_pn", "SimpleClassDiagrams"),
                                                                ("TM___RAM_print_pn", "TypeMapping"),
                                                                ("__merged_print_pn", "SimpleClassDiagrams"),
                                                                ("TM___merged_print_pn", "TypeMapping"),
                                                                ("print_pn", "__RAM_print_pn"),
                                                                ("TM_print_pn", "TypeMapping")])
        assert transformation_list() == set(list(expected_transformation_list) + [("ModelTransformation", "print_pn")])
        assert transformation_execute_MT("print_pn", {"PetriNet": "my_pn"}, {}, callback) == True

        assert set(log) == set(['"p1" --> 1',
                                '"p2" --> 2',
                                '"p3" --> 3'])

    def test_transform_add_MT_pn_simulate(self):
        """
        This method tests the execution of a somewhat realistic use of the Modelverse and its core functions, through the use of a simple Petri nets example.
        First, Petri net metamodels are created for both the design language and the runtime language.
        Both languages only differ marginally from each other, with the runtime language only adding information on the currently selected transition for execution.
        Afterwards, a trivial Petri net model is created in the design language.
        This part tests the domain-specific and meta-modelling concepts of the Modelverse.

        After all models are created, transformations are defined to map between both languages: from design to runtime, and vice versa.
        Additional transformations are created for in-place model simulation and the printing of a Petri net model.
        This tests the modification of models, through the use of model transformations.
        Due to the use of a separate design and runtime language, we test exogenous transformations.
        The simulation transformation takes a single step in the Petri net model, by firing one of the applicable transitions, and therefore tests endogenous transformations.
        """
        log = []

        def callback(value):
            log.append(value)

        model_add("PetriNet", "SimpleClassDiagrams", open("integration/code/pn_design.mvc", "r").read())
        model_add("PetriNet_Runtime", "SimpleClassDiagrams", open("integration/code/pn_runtime.mvc", "r").read())

        model_add("my_pn", "PetriNet", open("integration/code/pn_design_model.mvc", "r").read())

        def add_tracability_D2R():
            instantiate(None, "Association", ("PetriNet/Place", "PetriNet_Runtime/Place"), ID="D2R_PlaceLink")
            instantiate(None, "Association", ("PetriNet/Transition", "PetriNet_Runtime/Transition"), ID="D2R_TransitionLink")

        def add_tracability_R2D():
            instantiate(None, "Association", ("PetriNet_Runtime/Place", "PetriNet/Place"), ID="R2D_PlaceLink")
            instantiate(None, "Association", ("PetriNet_Runtime/Transition", "PetriNet/Transition"), ID="R2D_TransitionLink")

        transformation_add_MT({"PetriNet": "PetriNet"}, {}, "print_pn", open("integration/code/pn_print.mvc").read())
        transformation_add_MT({"PetriNet": "PetriNet"}, {"PetriNet_Runtime": "PetriNet_Runtime"}, "pn_design_to_runtime", open("integration/code/pn_design_to_runtime.mvc").read(), add_tracability_D2R)
        transformation_add_MT({"PetriNet_Runtime": "PetriNet_Runtime"}, {"PetriNet_Runtime": "PetriNet_Runtime"}, "pn_simulate", open("integration/code/pn_simulate.mvc").read())
        transformation_add_MT({"PetriNet_Runtime": "PetriNet_Runtime"}, {"PetriNet": "PetriNet"}, "pn_runtime_to_design", open("integration/code/pn_runtime_to_design.mvc").read(), add_tracability_R2D)

        log = []
        assert transformation_execute_MT("print_pn", {"PetriNet": "my_pn"}, {}, callback) == True
        assert set(log) == set(['"p1" --> 1',
                                '"p2" --> 2',
                                '"p3" --> 3'])

        assert transformation_execute_MT("pn_design_to_runtime", {"PetriNet": "my_pn"}, {"PetriNet_Runtime": "my_pn_RT"}) == True
        assert transformation_execute_MT("pn_simulate", {"PetriNet_Runtime": "my_pn_RT"}, {"PetriNet_Runtime": "my_pn_RT"}) == True
        assert transformation_execute_MT("pn_runtime_to_design", {"PetriNet_Runtime": "my_pn_RT"}, {"PetriNet": "my_pn"}) == True

        log = []
        assert transformation_execute_MT("print_pn", {"PetriNet": "my_pn"}, {}, callback) == True
        assert set(log) == set(['"p1" --> 0',
                                '"p2" --> 1',
                                '"p3" --> 5'])

    def test_transform_add_AL_pn_simulate(self):
        log = []

        def callback(value):
            log.append(value)

        model_add("PetriNet", "SimpleClassDiagrams", open("integration/code/pn_design.mvc", "r").read())
        model_add("PetriNet_Runtime", "SimpleClassDiagrams", open("integration/code/pn_runtime.mvc", "r").read())

        model_add("my_pn", "PetriNet", open("integration/code/pn_design_model.mvc", "r").read())

        def add_tracability_D2R():
            instantiate(None, "Association", ("PetriNet/Place", "PetriNet_Runtime/Place"), ID="D2R_PlaceLink")
            instantiate(None, "Association", ("PetriNet/Transition", "PetriNet_Runtime/Transition"), ID="D2R_TransitionLink")

        def add_tracability_R2D():
            instantiate(None, "Association", ("PetriNet_Runtime/Place", "PetriNet/Place"), ID="R2D_PlaceLink")
            instantiate(None, "Association", ("PetriNet_Runtime/Transition", "PetriNet/Transition"), ID="R2D_TransitionLink")

        transformation_add_MT({"PetriNet": "PetriNet"}, {}, "print_pn", open("integration/code/pn_print.mvc").read())
        transformation_add_MT({"PetriNet": "PetriNet"}, {"PetriNet_Runtime": "PetriNet_Runtime"}, "pn_design_to_runtime", open("integration/code/pn_design_to_runtime.mvc").read(), add_tracability_D2R)
        transformation_add_AL({"PetriNet_Runtime": "PetriNet_Runtime"}, {"PetriNet_Runtime": "PetriNet_Runtime"}, "pn_simulate", open("integration/code/pn_simulate.alc").read())
        transformation_add_MT({"PetriNet_Runtime": "PetriNet_Runtime"}, {"PetriNet": "PetriNet"}, "pn_runtime_to_design", open("integration/code/pn_runtime_to_design.mvc").read(), add_tracability_R2D)

        log = []
        assert transformation_execute_MT("print_pn", {"PetriNet": "my_pn"}, {}, callback) == True
        assert set(log) == set(['"p1" --> 1',
                                '"p2" --> 2',
                                '"p3" --> 3'])

        assert transformation_execute_MT("pn_design_to_runtime", {"PetriNet": "my_pn"}, {"PetriNet_Runtime": "my_pn_RT"}) == True
        assert transformation_execute_AL("pn_simulate", {"PetriNet_Runtime": "my_pn_RT"}, {"PetriNet_Runtime": "my_pn_RT"}) == True
        assert transformation_execute_MT("pn_runtime_to_design", {"PetriNet_Runtime": "my_pn_RT"}, {"PetriNet": "my_pn"}) == True

        log = []
        assert transformation_execute_MT("print_pn", {"PetriNet": "my_pn"}, {}, callback) == True
        assert set(log) == set(['"p1" --> 0',
                                '"p2" --> 1',
                                '"p3" --> 5'])

    def test_transform_add_MANUAL_pn_simulate(self):
        log = []

        def callback(value):
            log.append(value)

        def manual_callback():
            p1 = instantiate(None, "PetriNet_Runtime/Place")
            attr_assign(None, p1, "tokens", 1)
            attr_assign(None, p1, "name", "p1")
            p2 = instantiate(None, "PetriNet_Runtime/Place")
            attr_assign(None, p2, "tokens", 2)
            attr_assign(None, p2, "name", "p2")
            p3 = instantiate(None, "PetriNet_Runtime/Place")
            attr_assign(None, p3, "tokens", 3)
            attr_assign(None, p3, "name", "p3")
            t1 = instantiate(None, "PetriNet_Runtime/Transition")
            attr_assign(None, t1, "name", "t1")
            attr_assign(None, t1, "executing", False)
            p2t1 = instantiate(None, "PetriNet_Runtime/P2T", (p1, t1))
            attr_assign(None, p2t1, "weight", 1)
            p2t2 = instantiate(None, "PetriNet_Runtime/P2T", (p2, t1))
            attr_assign(None, p2t2, "weight", 1)
            t2p1 = instantiate(None, "PetriNet_Runtime/T2P", (t1, p3))
            attr_assign(None, t2p1, "weight", 2)

        model_add("PetriNet", "SimpleClassDiagrams", open("integration/code/pn_design.mvc", "r").read())
        model_add("PetriNet_Runtime", "SimpleClassDiagrams", open("integration/code/pn_runtime.mvc", "r").read())

        model_add("my_pn", "PetriNet", open("integration/code/pn_design_model.mvc", "r").read())

        def add_tracability_D2R():
            instantiate(None, "Association", ("PetriNet/Place", "PetriNet_Runtime/Place"), ID="D2R_PlaceLink")
            instantiate(None, "Association", ("PetriNet/Transition", "PetriNet_Runtime/Transition"), ID="D2R_TransitionLink")

        def add_tracability_R2D():
            instantiate(None, "Association", ("PetriNet_Runtime/Place", "PetriNet/Place"), ID="R2D_PlaceLink")
            instantiate(None, "Association", ("PetriNet_Runtime/Transition", "PetriNet/Transition"), ID="R2D_TransitionLink")

        transformation_add_MT({"PetriNet": "PetriNet"}, {}, "print_pn", open("integration/code/pn_print.mvc").read())
        transformation_add_MANUAL({"PetriNet": "PetriNet"}, {"PetriNet_Runtime": "PetriNet_Runtime"}, "pn_design_to_runtime", add_tracability_D2R)
        transformation_add_AL({"PetriNet_Runtime": "PetriNet_Runtime"}, {"PetriNet_Runtime": "PetriNet_Runtime"}, "pn_simulate", open("integration/code/pn_simulate.alc").read())
        transformation_add_MT({"PetriNet_Runtime": "PetriNet_Runtime"}, {"PetriNet": "PetriNet"}, "pn_runtime_to_design", open("integration/code/pn_runtime_to_design.mvc").read(), add_tracability_R2D)

        log = []
        assert transformation_execute_MT("print_pn", {"PetriNet": "my_pn"}, {}, callback) == True
        assert set(log) == set(['"p1" --> 1',
                                '"p2" --> 2',
                                '"p3" --> 3'])

        assert transformation_execute_MANUAL("pn_design_to_runtime", {"PetriNet": "my_pn"}, {"PetriNet_Runtime": "my_pn_RT"}, manual_callback) == True
        assert transformation_execute_AL("pn_simulate", {"PetriNet_Runtime": "my_pn_RT"}, {"PetriNet_Runtime": "my_pn_RT"}) == True
        assert transformation_execute_MT("pn_runtime_to_design", {"PetriNet_Runtime": "my_pn_RT"}, {"PetriNet": "my_pn"}) == True

        log = []
        assert transformation_execute_MT("print_pn", {"PetriNet": "my_pn"}, {}, callback) == True
        assert set(log) == set(['"p1" --> 0',
                                '"p2" --> 1',
                                '"p3" --> 5'])

    def test_process_model_trivial_pn_bigmain(self):
        model_add("PetriNet", "SimpleClassDiagrams", open("integration/code/pn_design.mvc", "r").read())
        model_add("ReachabilityGraph", "SimpleClassDiagrams", open("integration/code/reachability_graph.mvc", "r").read())
        model_add("pn_reachability", "ProcessModel", open("integration/code/pm_pn_reachability.mvc", "r").read())
        transformation_add_MT({}, {"PetriNet": "PetriNet"}, "initialize_PN", open("integration/code/initialize_PN.mvc", "r").read())
        transformation_add_MANUAL({"PetriNet": "PetriNet"}, {"PetriNet": "PetriNet"}, "refine_PN")
        transformation_add_AL({"PetriNet": "PetriNet"}, {"ReachabilityGraph": "ReachabilityGraph"}, "reachability", open("integration/code/reachability.alc", "r").read())
        transformation_add_MT({"ReachabilityGraph": "ReachabilityGraph"}, {}, "reachability_print", open("integration/code/reachabilitygraph_print.mvc", 'r').read())

        def callback_refine_PN():
            p1 = instantiate(None, "PetriNet/Place")
            attr_assign(None, p1, "name", "p1")
            attr_assign(None, p1, "tokens", 1)

            t1 = instantiate(None, "PetriNet/Transition")
            attr_assign(None, t1, "name", "t1")

            p2t = instantiate(None, "PetriNet/P2T", (p1, t1))
            attr_assign(None, p2t, "weight", 1)

        log = set([])
        def callback_print(value):
            log.add(value)

        process_execute("pn_reachability", "my_", {"refine_PN": callback_refine_PN, "reachability_print": callback_print})

        assert log == set(['"0": {"p1": 1, }',
                           '"1": {"p1": 0, }',
                           '"0" --["t1"]--> "1"'])

    def test_process_model_trivial_pn_subfunction(self):
        model_add("PetriNet", "SimpleClassDiagrams", open("integration/code/pn_design.mvc", "r").read())
        model_add("ReachabilityGraph", "SimpleClassDiagrams", open("integration/code/reachability_graph.mvc", "r").read())
        model_add("pn_reachability", "ProcessModel", open("integration/code/pm_pn_reachability.mvc", "r").read())
        transformation_add_MT({}, {"PetriNet": "PetriNet"}, "initialize_PN", open("integration/code/initialize_PN.mvc", "r").read())
        transformation_add_MANUAL({"PetriNet": "PetriNet"}, {"PetriNet": "PetriNet"}, "refine_PN")
        transformation_add_AL({"PetriNet": "PetriNet"}, {"ReachabilityGraph": "ReachabilityGraph"}, "reachability", open("integration/code/reachability_subfunction.alc", "r").read())
        transformation_add_MT({"ReachabilityGraph": "ReachabilityGraph"}, {}, "reachability_print", open("integration/code/reachabilitygraph_print.mvc", 'r').read())

        def callback_refine_PN():
            p1 = instantiate(None, "PetriNet/Place")
            attr_assign(None, p1, "name", "p1")
            attr_assign(None, p1, "tokens", 1)

            t1 = instantiate(None, "PetriNet/Transition")
            attr_assign(None, t1, "name", "t1")

            p2t = instantiate(None, "PetriNet/P2T", (p1, t1))
            attr_assign(None, p2t, "weight", 1)

        log = set([])
        def callback_print(value):
            log.add(value)

        process_execute("pn_reachability", "my_", {"refine_PN": callback_refine_PN, "reachability_print": callback_print})

        assert log == set(['"0": {"p1": 1, }',
                           '"1": {"p1": 0, }',
                           '"0" --["t1"]--> "1"'])

    def test_render(self):
        model_add("CausalBlockDiagrams", "SimpleClassDiagrams", open("integration/code/cbd_design.mvc", 'r').read())
        model_add("MM_rendered_graphical", "SimpleClassDiagrams", open("models/MM_rendered_graphical.mvc", 'r').read())
        model_add("my_CBD", "CausalBlockDiagrams", open("integration/code/my_cbd.mvc", 'r').read())

        def add_tracability():
            instantiate(None, "Association", ("abstract/Block", "rendered/Group"), ID="TracabilityLink")

        transformation_add_MT({"abstract": "CausalBlockDiagrams", "rendered": "MM_rendered_graphical"}, {"abstract": "CausalBlockDiagrams", "rendered": "MM_rendered_graphical"}, "render_graphical_CBD", open("models/CBD_mapper.mvc", 'r').read(), add_tracability)
        result = model_render("my_CBD", "render_graphical_CBD")
        assert len(result) == 23