test(tes,wes): add comprehensive unit tests

.github/workflows/ci.yml

@@ -25,7 +25,7 @@ jobs:
 
     - name: Lint with Ruff
       run: |
-        poetry run ruff check crategen/
+        poetry run ruff check crategen/ tests/
 
     - name: Type check with Mypy
       run: |
@@ -39,6 +39,6 @@ jobs:
       run: |
         poetry add pytest pytest-cov pytest-mock
 
-    # - name: Run tests
-    #   run: |
-    #     poetry run pytest --cov=crategen
+    - name: Run tests
+      run: |
+        poetry run pytest --cov=crategen

crategen/cli.py

@@ -5,10 +5,10 @@
 @click.command()
 @click.option('--input', prompt='Input file', help='Path to the input JSON file.')
 @click.option('--output', prompt='Output file', help='Path to the output JSON file.')
-@click.option('--conversion-type', prompt='Conversion type', type=click.Choice(['tes-to-wrroc', 'wes-to-wrroc']), help='Type of conversion to perform.')
+@click.option('--conversion-type', prompt='Conversion type', type=click.Choice(['tes-to-wrroc', 'wes-to-wrroc', 'wrroc-to-tes', 'wrroc-to-wes']), help='Type of conversion to perform.')
 def cli(input, output, conversion_type):
     """
-    Command Line Interface for converting TES/WES to WRROC.
+    Command Line Interface for converting TES/WES to WRROC and vice versa.
     """
     manager = ConverterManager()
 
@@ -21,6 +21,10 @@ def cli(input, output, conversion_type):
         result = manager.convert_tes_to_wrroc(data)
     elif conversion_type == 'wes-to-wrroc':
         result = manager.convert_wes_to_wrroc(data)
+    elif conversion_type == 'wrroc-to-tes':
+        result = manager.convert_wrroc_to_tes(data)
+    elif conversion_type == 'wrroc-to-wes':
+        result = manager.convert_wrroc_to_wes(data)
 
     # Save the result to the output JSON file
     with open(output, 'w') as output_file:

crategen/converter_manager.py

@@ -11,3 +11,9 @@ def convert_tes_to_wrroc(self, tes_data):
 
     def convert_wes_to_wrroc(self, wes_data):
         return self.wes_converter.convert_to_wrroc(wes_data)
+
+    def convert_wrroc_to_tes(self, wrroc_data):
+        return self.tes_converter.convert_from_wrroc(wrroc_data)
+
+    def convert_wrroc_to_wes(self, wrroc_data):
+        return self.wes_converter.convert_from_wrroc(wrroc_data)

crategen/converters/tes_converter.py

@@ -1,52 +1,43 @@
+from pydantic import ValidationError
 from .abstract_converter import AbstractConverter
 from .utils import convert_to_iso8601
+from ..models import TESData
+from ..validators import validate_wrroc_tes
 
 class TESConverter(AbstractConverter):
 
-    def convert_to_wrroc(self, tes_data):
-        # Validate and extract data with defaults
-        id = tes_data.get("id", "")
-        name = tes_data.get("name", "")
-        description = tes_data.get("description", "")
-        executors = tes_data.get("executors", [{}])
-        inputs = tes_data.get("inputs", [])
-        outputs = tes_data.get("outputs", [])
-        creation_time = tes_data.get("creation_time", "")
-        end_time = tes_data.get("logs", [{}])[0].get("end_time", "")  # Corrected to fetch from logs
+    def convert_to_wrroc(self, tes_data: dict) -> dict:
+        try:
+            validated_tes_data = TESData(**tes_data)
+        except ValidationError as e:
+            raise ValueError(f"Invalid TES data: {e}")
 
-        # Convert to WRROC
         wrroc_data = {
-            "@id": id,
-            "name": name,
-            "description": description,
-            "instrument": executors[0].get("image", None) if executors else None,
-            "object": [{"@id": input.get("url", ""), "name": input.get("path", "")} for input in inputs],
-            "result": [{"@id": output.get("url", ""), "name": output.get("path", "")} for output in outputs],
-            "startTime": convert_to_iso8601(creation_time),
-            "endTime": convert_to_iso8601(end_time),
+            "@id": validated_tes_data.id,
+            "name": validated_tes_data.name,
+            "description": validated_tes_data.description,
+            "instrument": validated_tes_data.executors[0].image if validated_tes_data.executors else None,
+            "object": [{"@id": input.url, "name": input.path} for input in validated_tes_data.inputs],
+            "result": [{"@id": output.url, "name": output.path} for output in validated_tes_data.outputs],
+            "startTime": convert_to_iso8601(validated_tes_data.creation_time),
+            "endTime": convert_to_iso8601(validated_tes_data.logs[0].end_time) if validated_tes_data.logs else None,
         }
         return wrroc_data
 
-    def convert_from_wrroc(self, wrroc_data):
-        # Validate and extract data with defaults
-        id = wrroc_data.get("@id", "")
-        name = wrroc_data.get("name", "")
-        description = wrroc_data.get("description", "")
-        instrument = wrroc_data.get("instrument", "")
-        object_data = wrroc_data.get("object", [])
-        result_data = wrroc_data.get("result", [])
-        start_time = wrroc_data.get("startTime", "")
-        end_time = wrroc_data.get("endTime", "")
+    def convert_from_wrroc(self, data: dict) -> dict:
+        try:
+            data_validated = validate_wrroc_tes(data)
+        except ValidationError as e:
+            raise ValueError(f"Invalid WRROC data: {e}")
 
-        # Convert from WRROC to TES
         tes_data = {
-            "id": id,
-            "name": name,
-            "description": description,
-            "executors": [{"image": instrument}],
-            "inputs": [{"url": obj.get("@id", ""), "path": obj.get("name", "")} for obj in object_data],
-            "outputs": [{"url": res.get("@id", ""), "path": res.get("name", "")} for res in result_data],
-            "creation_time": start_time,
-            "logs": [{"end_time": end_time}],  # Added to logs
+            "id": data_validated.id,
+            "name": data_validated.name,
+            "description": data_validated.description,
+            "executors": [{"image": data_validated.instrument}],
+            "inputs": [{"url": obj.id, "path": obj.name} for obj in data_validated.object],
+            "outputs": [{"url": res.id, "path": res.name} for res in data_validated.result],
+            "creation_time": data_validated.startTime,
+            "logs": [{"end_time": data_validated.endTime}],
         }
-        return tes_data
+        return tes_data

crategen/converters/wes_converter.py

@@ -1,46 +1,43 @@
+from pydantic import ValidationError
 from .abstract_converter import AbstractConverter
+from ..models import WESData
 from .utils import convert_to_iso8601
+from ..validators import validate_wrroc_wes
 
 class WESConverter(AbstractConverter):
 
-    def convert_to_wrroc(self, wes_data):
-        # Validate and extract data with defaults
-        run_id = wes_data.get("run_id", "")
-        name = wes_data.get("run_log", {}).get("name", "")
-        state = wes_data.get("state", "")
-        start_time = wes_data.get("run_log", {}).get("start_time", "")
-        end_time = wes_data.get("run_log", {}).get("end_time", "")
-        outputs = wes_data.get("outputs", {})
+    def convert_to_wrroc(self, wes_data: dict) -> dict:
+        try:
+            wes_model = WESData(**wes_data)
+        except ValidationError as e:
+            raise ValueError(f"Invalid WES data: {e}")
+        outputs = wes_model.outputs
 
-        # Convert to WRROC
         wrroc_data = {
-            "@id": run_id,
-            "name": name,
-            "status": state,
-            "startTime": convert_to_iso8601(start_time),
-            "endTime": convert_to_iso8601(end_time),
-            "result": [{"@id": output.get("location", ""), "name": output.get("name", "")} for output in outputs],
+            "@id": wes_model.run_id,
+            "name": wes_model.run_log.name,
+            "status": wes_model.state,
+            "startTime": convert_to_iso8601(wes_model.run_log.start_time),
+            "endTime": convert_to_iso8601(wes_model.run_log.end_time),
+            "result": [{"@id": output.location, "name": output.name} for output in outputs],
         }
         return wrroc_data
 
-    def convert_from_wrroc(self, wrroc_data):
-        # Validate and extract data with defaults
-        run_id = wrroc_data.get("@id", "")
-        name = wrroc_data.get("name", "")
-        start_time = wrroc_data.get("startTime", "")
-        end_time = wrroc_data.get("endTime", "")
-        state = wrroc_data.get("status", "")
-        result_data = wrroc_data.get("result", [])
-
-        # Convert from WRROC to WES
+
+    def convert_from_wrroc(self, data: dict) -> dict:
+        try:
+            data_validated = validate_wrroc_wes(data)
+        except ValidationError as e:
+            raise ValueError(f"Invalid WRROC data: {e}")
+
         wes_data = {
-            "run_id": run_id,
+            "run_id": data_validated.id,
             "run_log": {
-                "name": name,
-                "start_time": start_time,
-                "end_time": end_time,
+                "name": data_validated.name,
+                "start_time": data_validated.startTime,
+                "end_time": data_validated.endTime,
             },
-            "state": state,
-            "outputs": [{"location": res.get("@id", ""), "name": res.get("name", "")} for res in result_data],
+            "state": data_validated.status,
+            "outputs": [{"location": res.id, "name": res.name} for res in data_validated.result],
         }
-        return wes_data
+        return wes_data

crategen/models.py

@@ -0,0 +1,105 @@
+from pydantic import BaseModel
+from typing import Optional
+
+class Executor(BaseModel):
+    image: str
+    command: list[str]
+
+class TESInputs(BaseModel):
+    url: str
+    path: str
+
+class TESOutputs(BaseModel):
+    url: str
+    path: str
+
+class TESLogs(BaseModel):
+    end_time: Optional[str] = None
+
+class TESData(BaseModel):
+    id: str
+    name: str
+    description: Optional[str] = ""
+    executors: list[Executor]
+    inputs: list[TESInputs]
+    outputs: list[TESOutputs]
+    creation_time: str
+    logs: list[TESLogs]
+
+    class Config:
+        extra = "forbid"
+
+class WESRunLog(BaseModel):
+    name: Optional[str] = None
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+    cmd: Optional[list[str]] = None
+    stdout: Optional[str] = None
+    stderr: Optional[str] = None
+    exit_code: Optional[int] = None
+
+class WESOutputs(BaseModel):
+    location: str
+    name: str
+
+class WESRequest(BaseModel):
+    workflow_params: dict[str, str]
+    workflow_type: str
+    workflow_type_version: str
+    tags: Optional[dict[str, str]] = None
+
+class WESData(BaseModel):
+    run_id: str
+    request: WESRequest
+    state: str
+    run_log: WESRunLog
+    task_logs: Optional[list[WESRunLog]] = None
+    outputs: list[WESOutputs]
+
+    class Config:
+        extra = "forbid"
+
+class WRROCInputs(BaseModel):
+    id: str
+    name: str
+
+class WRROCOutputs(BaseModel):
+    id: str
+    name: str
+
+class WRROCData(BaseModel):
+    id: str
+    name: str
+    description: Optional[str] = ""
+    instrument: Optional[str] = None
+    object: list[WRROCInputs]
+    result: list[WRROCOutputs]
+    startTime: Optional[str] = None
+    endTime: Optional[str] = None
+
+    class Config:
+        extra = "forbid"
+
+class WRROCDataTES(BaseModel):
+    id: str
+    name: str
+    description: Optional[str] = ""
+    instrument: Optional[str] = None
+    object: list[WRROCInputs]
+    result: list[WRROCOutputs]
+    startTime: Optional[str] = None
+    endTime: Optional[str] = None
+
+    class Config:
+        extra = "forbid"
+
+class WRROCDataWES(BaseModel):
+    id: str
+    name: str
+    status: str
+    result: list[WRROCOutputs]
+    startTime: Optional[str] = None
+    endTime: Optional[str] = None
+
+    class Config:
+        extra = "forbid"

crategen/validators.py

@@ -0,0 +1,56 @@
+from pydantic import ValidationError
+from .models import WRROCData, WRROCDataTES, WRROCDataWES
+
+def validate_wrroc(data: dict) -> WRROCData:
+    """
+    Validate that the input data is a valid WRROC entity.
+
+    Args:
+        data (dict): The input data to validate.
+
+    Returns:
+        WRROCData: The validated WRROC data.
+
+    Raises:
+        ValueError: If the data is not valid WRROC data.
+    """
+    try:
+        return WRROCData(**data)
+    except ValidationError as e:
+        raise ValueError(f"Invalid WRROC data: {e}")
+
+def validate_wrroc_tes(data: dict) -> WRROCDataTES:
+    """
+    Validate that the input data is a valid WRROC entity for TES.
+
+    Args:
+        data (dict): The input data to validate.
+
+    Returns:
+        WRROCDataTES: The validated WRROC data for TES.
+
+    Raises:
+        ValueError: If the data is not valid WRROC data for TES.
+    """
+    try:
+        return WRROCDataTES(**data)
+    except ValidationError as e:
+        raise ValueError(f"Invalid WRROC data: {e}")
+
+def validate_wrroc_wes(data: dict) -> WRROCDataWES:
+    """
+    Validate that the input data is a valid WRROC entity for WES.
+
+    Args:
+        data (dict): The input data to validate.
+
+    Returns:
+        WRROCDataWES: The validated WRROC data for WES.
+
+    Raises:
+        ValueError: If the data is not valid WRROC data for WES.
+    """
+    try:
+        return WRROCDataWES(**data)
+    except ValidationError as e:
+        raise ValueError(f"Invalid WRROC data: {e}")