drawio2oml/test/run_tests.py

import sys
import os
import io
import pprint
import unittest

from drawio2py import abstract_syntax as dio_as
from drawio2py import parser as dio_parser
from drawio2py import generator as dio_generator
from drawio2py import util
from drawio2oml.drawio import oml_generator as dio_oml_generator
from drawio2oml.pm import parser as pm_parser
from drawio2oml.pm import oml_generator as pm_oml_generator
from drawio2oml.pt import renderer as pt_renderer
from drawio2oml.pt import abstract_syntax as pt_as

DATADIR = os.path.join(os.path.dirname(__file__), "data")

class DummyOutput:
    def write(self, str):
        pass

def run_drawio_test(filename):
    # Parse (1st time):
    inputfile = os.path.join(DATADIR,filename)
    asyntax = dio_parser.Parser.parse(inputfile)

    # Print abstract syntax:
    # pprint.pprint(asyntax, indent=2, compact=True)

    # Generate .drawio (1st time):
    csyntax = io.BytesIO()
    dio_generator.generate(asyntax, csyntax)
    csyntax.seek(0)

    # Print generated .drawio
    # print(csyntax.getvalue())

    # Parse (2nd time):

    asyntax2 = dio_parser.Parser.parse(csyntax)

    # Generate .drawio (2nd time):
    csyntax2 = io.BytesIO()
    dio_generator.generate(asyntax2, csyntax2)
    csyntax2.seek(0)

    if (csyntax.getvalue() != csyntax2.getvalue()):
        # print(csyntax.getvalue())
        # print(csyntax2.getvalue())
        raise Exception("Files differ after round-trip!")

    for page in asyntax.pages:
        dio_oml_generator.write_oml(
            input_uri="file://"+filename,
            drawio_page=page,
            model_name="MODEL",
            names=dio_oml_generator.assign_names(page),
            ostream=DummyOutput())

def run_pm_test(filename):
    inputfile = os.path.join(DATADIR,filename)
    dio_asyntax = dio_parser.Parser.parse(os.path.join(DATADIR, inputfile))

    # pprint.pprint(dio_asyntax, indent=2, compact=True)

    for page_index, page in enumerate(dio_asyntax.pages):
        for layer_index, layer in enumerate(page.root.children):
            try:
                pm_asyntax, traceability_links = pm_parser.parse(layer)

                # pprint.pprint(pm_asyntax, indent=2, compact=True)

            except pm_parser.ParseError as e:
                print("Could not parse page", page_index)
                continue

            dio_names = dio_oml_generator.assign_names(page)
            pm_names = pm_oml_generator.assign_names(pm_asyntax)

            # OML-description of drawio-diagram
            dio_oml_generator.write_oml(
                input_uri="file://"+inputfile,
                drawio_page=page,
                model_name="MODEL",
                names=dio_names,
                ostream=DummyOutput())

            # OML-description of process model
            pm_oml_generator.write_oml(
                input_uri=inputfile,
                model_name="MODEL",
                asyntax=pm_asyntax,
                names=pm_names,
                ostream=DummyOutput())

            # OML-description of traceability links between drawio-diagram and process model
            pm_oml_generator.write_corr_oml(
                input_uri=inputfile,
                model_name="MODEL",
                traceability_links=traceability_links,
                model_names=pm_names,
                drawio_names=dio_names,
                ostream=DummyOutput())

            print(inputfile, "OK")

class Tests(unittest.TestCase):
    def test_drawio1(self):
        run_drawio_test("drawio/test.drawio")

    def test_drawio2(self):
        run_drawio_test("drawio/overview.drawio")

    def test_pm1(self):
        run_pm_test("pm/TrivialPM.drawio")

    def test_pm2(self):
        run_pm_test("pm/SlightlyLessTrivialPM.drawio")

    def test_pm3(self):
        run_pm_test("pm/MyFancyPM.drawio")

    # In order to test rendering of Process Traces, we need the path of the shape_libs dir (from drawio repo). Tests don't have command line arguments, so let's get it from an environment variable:
    @unittest.skipIf("DRAWIOSHAPELIBS" not in os.environ, "DRAWIOSHAPELIBS environment variable not set")
    def test_render_pt(self):

        a0 = pt_as.Artifact(
            tag="v0",
            guid="XXX",
            location="XXX",
            type="xopp",
            parentVersion=None)
        e0 = pt_as.StartTraceEvent(
            pm="MyPM",
            timestamp="2011-06-01T19:16:58.869Z",
            after=None)
        e1 = pt_as.StartActivityEvent(
            timestamp="2011-06-01T19:16:58.869Z",
            after=e0,
            activity="activity",
            port="cin",
            consumes=[])
        e2 = pt_as.EndActivityEvent(
            timestamp="2011-06-01T19:16:58.869Z",
            after=e1,
            activity="activity",
            port="cout",
            produces=[a0])
        e3 = pt_as.EndTraceEvent(
            timestamp="2011-06-01T19:16:58.869Z",
            after=e2)

        id_gen = util.DrawioIDGenerator()
        page = util.generate_empty_page(id_gen, "Generated PT")
        default_layer = page.root.children[0]
        shapelib_dir = os.environ["DRAWIOSHAPELIBS"]
        pt_renderer.render(shapelib_dir=shapelib_dir, last_event=e3, parent=default_layer, id_gen=id_gen)
        file = dio_as.DrawIOFile(filename="XXX", compressed=False, version="20", pages=[page])

        # import pprint
        # pprint.pprint(file)

        import drawio2py.generator
        drawio2py.generator.generate(file, DummyOutput())