180 remove dependency on test harness (#182)

* 180 - replace test harness Job with new class and tests

* 180 - Remove install of test harness and remove from readme

* 180 - remove mention of erebus

* 180 - update requirements

Author: FreddieMatherSmartDCSIT

.github/workflows/PythonLinting.yml

@@ -26,7 +26,7 @@ jobs:
 
           pip install -r requirements.txt
       
-      - name: Install janus and erebus as packages
+      - name: Install janus as package
         run: |
           chmod +x ./scripts/install_repositories.sh && ./scripts/install_repositories.sh
 

.github/workflows/test-workflow.yml

@@ -37,7 +37,7 @@ jobs:
           conda install -y -c conda-forge cvxopt
           conda install -y -c conda-forge pygraphviz
 
-      - name: Install janus and erebus as packages
+      - name: Install janus as package
         run: |
           chmod +x ./scripts/install_repositories.sh && ./scripts/install_repositories.sh
       
@@ -74,7 +74,7 @@ jobs:
           sudo apt install -y libsuitesparse-dev
           sudo apt install -y libsuitesparse-dev
 
-      - name: Install janus and erebus as packages
+      - name: Install janus as package
         run: |
           chmod +x ./scripts/install_repositories.sh && ./scripts/install_repositories.sh
       
@@ -106,7 +106,7 @@ jobs:
           python-version: '3.11.9'
           cache: 'pip'
 
-      - name: Install janus and erebus as packages
+      - name: Install janus as package
         run: |
           chmod +x ./scripts/install_repositories.sh && ./scripts/install_repositories.sh
       

README.md

@@ -339,17 +339,13 @@ Documentation for tel2puml can be found in the [docs](docs) folder. This contain
 
 ## Dependencies
 
-TEL2PUML depends on two other repositories:
+TEL2PUML depends on one other repository:
 
 1. [Janus](https://github.com/xtuml/janus): 
 
    Janus ingests PUML activity diagram files and generates event sequences from them.
 
-2. [Erebus](https://github.com/xtuml/erebus):
-
-   Erebus is a test harness framework for the protocol verifier.
-
-These dependencies are automatically managed when using the devcontainer setup or when running the `install_repositories.sh` script during manual installation.
+This dependency is automatically managed when using the devcontainer setup or when running the `install_repositories.sh` script during manual installation.
 
 ## Contributing
 

requirements.txt

@@ -10,4 +10,6 @@ numba~=0.59.0
 ijson~=3.3.0
 xxhash~=3.5.0
 pydantic~=2.9.1
-jq~=1.8.0
+jq~=1.8.0
+pyyaml~=6.0.2
+sqlalchemy~=2.0.35

scripts/install_repositories.sh

@@ -12,15 +12,4 @@ git checkout tags/v1.0.0 -b latest
 pip install -r requirements.txt
 pip install .
 cd ..
-rm -f -r janus/
-
-# erebus - test harness
-cd /tmp/
-git clone https://github.com/xtuml/erebus.git
-cd erebus
-git fetch --all --tags
-git checkout tags/v0.2.1-beta -b latest 
-pip install -r requirements.txt
-pip install .
-cd ..
-rm -f -r erebus/
+rm -f -r janus/

tel2puml/pv_event_simulator.py

@@ -2,15 +2,92 @@
 
 from typing import Generator, Any, Optional
 import random
+from uuid import uuid4
 
-from test_harness.protocol_verifier.simulator_data import (  # type: ignore[import-untyped]  # noqa: E501
-    Job,
-    generate_single_events,
-)
 from test_event_generator.io.run import puml_file_to_test_events  # type: ignore[import-untyped]  # noqa: E501
 from tel2puml.tel2puml_types import DUMMY_START_EVENT, PVEvent, DUMMY_EVENT
 
 
+class Job:
+    """A class to represent a job."""
+
+    def __init__(self) -> None:
+        """Initializes the job."""
+        self.events: list[PVEvent] = []
+
+    def parse_input_job(self, jobfile: list[dict[str, Any]]) -> None:
+        """Parses the input job file.
+
+        :param jobfile: The job file to parse.
+        :type jobfile: `list`[`dict`[`str`, `Any`]]
+        """
+        if len(self.events) > 0:
+            raise ValueError("The job already has events.")
+        for event in jobfile:
+            pv_event = transform_dict_into_pv_event(event)
+            self.events.append(pv_event)
+
+    @staticmethod
+    def sim_event(
+        event: PVEvent,
+        job_id: str,
+        event_id_map: dict[str, str],
+    ) -> PVEvent:
+        """Simulates an event.
+
+        :param event: The event to simulate.
+        :type event: :class:`PVEvent`
+        :param job_id: The job id.
+        :type job_id: `str`
+        :param event_id_map: The event id map.
+        :type event_id_map: `dict`[`str`, `str`]
+        :return: The simulated event.
+        :rtype: :class:`PVEvent`
+        raises ValueError: If the some event ids are not in the event id map.
+        """
+        previous_events: list[str] = []
+        if "previousEventIds" in event:
+            if isinstance(event["previousEventIds"], str):
+                previous_events = [event["previousEventIds"]]
+            else:
+                previous_events = event["previousEventIds"]
+        if not set([*previous_events, event["eventId"]]).issubset(
+            event_id_map.keys()
+        ):
+            raise ValueError(
+                "The some event ids are not in the event id map."
+            )
+        sim_event = event.copy()
+        sim_event["eventId"] = event_id_map[event["eventId"]]
+        sim_event["jobId"] = job_id
+        sim_event["previousEventIds"] = [
+            event_id_map[previous_event_id]
+            for previous_event_id in previous_events
+        ]
+        return sim_event
+
+    def create_new_event_id_map(self) -> dict[str, str]:
+        """Creates a new event id map.
+
+        :return: The new event id map.
+        :rtype: `dict`[`str`, `str`]
+        """
+        return {event["eventId"]: str(uuid4()) for event in self.events}
+
+    def simulate_job(self) -> Generator[PVEvent, Any, None]:
+        """Simulates the job.
+
+        :return: A generator that yields the events of the job.
+        :rtype: `Generator`[:class:`PVEvent`, `Any`, `None`]
+        """
+        event_id_map: dict[str, str] = self.create_new_event_id_map()
+        job_id = str(uuid4())
+        for event in self.events:
+            yield self.sim_event(
+                event, job_id, event_id_map
+            )
+
+
 def generate_test_data(
     input_puml_file: str,
     template_all_paths: bool = True,
@@ -222,9 +299,8 @@ def generate_event_jsons(
     :return: A generator that yields the event jsons.
     :rtype: `Generator`[`PVEvent`, `Any`, `None`]
     """
-    for generator_of_datums in generate_single_events(jobs):
-        for datum in generator_of_datums:
-            yield transform_dict_into_pv_event(datum.kwargs["list_dict"][0])
+    for job in jobs:
+        yield from job.simulate_job()
 
 
 def generate_valid_jobs_from_puml_file(
@@ -250,5 +326,5 @@ def generate_valid_jobs_from_puml_file(
         list(test_jobs_with_info.keys())[0]
     ]["ValidSols"][0]:
         job = Job()
-        job.parse_input_jobfile(test_job_event_list)
+        job.parse_input_job(test_job_event_list)
         yield job

tests/tel2puml/test_pv_event_simulator.py

@@ -1,10 +1,127 @@
 """tests for module test_data_creation.py"""
+from typing import Any
+
+import pytest
+from pytest import MonkeyPatch
+
 from tel2puml.pv_event_simulator import (
     generate_valid_jobs_from_puml_file,
     generate_event_jsons,
     generate_test_data,
-    generate_test_data_event_sequences_from_puml
+    generate_test_data_event_sequences_from_puml,
+    Job,
 )
+from tel2puml.tel2puml_types import PVEvent
+
+
+class TestJob:
+    """Test class for Job"""
+    def input_job(self) -> list[PVEvent]:
+        """Returns a list of PVEvent objects"""
+        return [
+            PVEvent(
+                eventType="A",
+                jobId="B",
+                timestamp="2021-01-01T00:00:00",
+                eventId=f"{i}",
+                jobName="C",
+                applicationName="D",
+                previousEventIds=[] if i == 0 else [f"{i-1}"],
+            )
+            for i in range(2)
+        ]
+
+    def input_job_with_dict(self) -> list[dict[str, Any]]:
+        """Returns a list of dictionaries representing PVEvent objects"""
+        return [
+            {**event} for event in self.input_job()
+        ]
+
+    def test_init(self) -> None:
+        """tests for Job.__init__"""
+        job = Job()
+        assert job.events == []
+
+    def test_parse_input_job(self) -> None:
+        """tests for Job.parse_input_job_file"""
+        job = Job()
+        job.parse_input_job(self.input_job_with_dict())
+        assert len(job.events) == 2
+        assert job.events == self.input_job()
+
+    def test_sim_event(self) -> None:
+        """tests for Job.sim_event"""
+        events = self.input_job()
+        event = events[1]
+        sim_event = Job.sim_event(event, "X", {"0": "map0", "1": "map1"})
+        expected_event = PVEvent(
+            eventType="A",
+            jobId="X",
+            timestamp="2021-01-01T00:00:00",
+            eventId="map1",
+            jobName="C",
+            applicationName="D",
+            previousEventIds=["map0"],
+        )
+        assert sim_event == expected_event
+        # test case where event id map does not contain the event id
+        with pytest.raises(ValueError):
+            Job.sim_event(event, "X", {"0": "map0"})
+        # test case where event id map does not contain the previous event id
+        with pytest.raises(ValueError):
+            Job.sim_event(event, "X", {"1": "map1"})
+        # test positive case where the previous event is a string
+        event["previousEventIds"] = "0"
+        sim_event = Job.sim_event(event, "X", {"0": "map0", "1": "map1"})
+        assert sim_event == expected_event
+
+    @staticmethod
+    @pytest.fixture
+    def patch_uuid4(monkeypatch: MonkeyPatch) -> None:
+        """fixture to patch uuid4"""
+        import tel2puml.pv_event_simulator
+
+        to_pop_from = ["map0", "map1", "X"]
+        monkeypatch.setattr(
+            tel2puml.pv_event_simulator, "uuid4", lambda: to_pop_from.pop(0)
+        )
+
+    @pytest.mark.usefixtures("patch_uuid4")
+    def test_create_new_event_id_map(self) -> None:
+        """tests for Job.create_new_event_id_map"""
+        job = Job()
+        job.parse_input_job(self.input_job_with_dict())
+        event_id_map = job.create_new_event_id_map()
+        assert event_id_map == {"0": "map0", "1": "map1"}
+        # test case where the job has no events
+        job.events = []
+        event_id_map = job.create_new_event_id_map()
+        assert event_id_map == {}
+
+    @pytest.mark.usefixtures("patch_uuid4")
+    def test_simulate_job(self) -> None:
+        """tests for Job.simulate_job"""
+        job = Job()
+        job.parse_input_job(self.input_job_with_dict())
+        events = list(job.simulate_job())
+        assert len(events) == 2
+        for i, out_event, expected_event in zip(
+            range(2), events, self.input_job()
+        ):
+            assert (
+                out_event["applicationName"]
+                == expected_event["applicationName"]
+            )
+            assert out_event["eventType"] == expected_event["eventType"]
+            assert out_event["jobId"] == "X"
+            assert out_event["timestamp"] == expected_event["timestamp"]
+            assert out_event["jobName"] == expected_event["jobName"]
+            if i == 0:
+                assert out_event["previousEventIds"] == []
+                assert out_event["eventId"] == "map0"
+            else:
+                assert out_event["previousEventIds"] == ["map0"]
+                assert out_event["eventId"] == "map1"
 
 
 def test_generate_valid_jobs_from_puml_file() -> None:
@@ -15,7 +132,7 @@ def test_generate_valid_jobs_from_puml_file() -> None:
     assert len(result) == 1
     job = result[0]
     assert len(job.events) == 6
-    assert set([event.event_type for event in job.events]) == set(
+    assert set([event["eventType"] for event in job.events]) == set(
         ["A", "B", "C", "D", "E", "F"]
     )