testbench2robotframework 0.8.0a3__tar.gz → 0.8.0a5__tar.gz

{testbench2robotframework-0.8.0a3 → testbench2robotframework-0.8.0a5}/.gitignore

@@ -157,4 +157,11 @@ README_new.md
 report/
 reportt/
 itorx_report/
-config.json
+config.json
+resources/
+robot.toml
+.robot.toml
+cli-export-config.json
+cli-import-config.json
+robot_tests/
+reports/

{testbench2robotframework-0.8.0a3 → testbench2robotframework-0.8.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testbench2robotframework
-Version: 0.8.0a3
+Version: 0.8.0a5
 Summary: Robot Framework Code Generator from Keyword-Driven Tests in imbus TestBench 3.0 and newer
 Author-email: imbus AG <support@imbus.de>
 Requires-Python: >= 3.10

{testbench2robotframework-0.8.0a3 → testbench2robotframework-0.8.0a5}/testbench2robotframework/__init__.py

@@ -17,4 +17,4 @@ suites and enhancing the TestBench report with execution results from Robot Fram
 
 from .testbench2robotframework import testbench2robotframework  # noqa: F401
 
-__version__ = "0.8.0a3"
+__version__ = "0.8.0a5"

{testbench2robotframework-0.8.0a3 → testbench2robotframework-0.8.0a5}/testbench2robotframework/cli.py

@@ -11,9 +11,12 @@ from .config import (
     DEFAULT_GENERATION_DIRECTORY,
     DEFAULT_LIBRARY_REGEX,
     DEFAULT_LIBRARY_ROOTS,
+    DEFAULT_RESOURCE_DIRECTORY_REGEX,
     DEFAULT_RESOURCE_REGEX,
     DEFAULT_RESOURCE_ROOTS,
+    find_private_robot_toml,
     find_pyproject_toml,
+    find_robot_toml,
     get_testbench2robotframework_toml_dict,
 )
 from .json_reader import read_json
@@ -72,8 +75,8 @@ def testbench2robotframework_cli():
 @click.option(
     "--fully-qualified",
     is_flag=True,
-    help="""Option to call Robot Framework keywords by their
-         fully qualified name in the generated test suites.""",
+    help="""Calls Robot Framework keywords by their fully
+    qualified names in the generated test suites.""",
 )
 @click.option(
     "-d",
@@ -94,12 +97,20 @@ def testbench2robotframework_cli():
     type=click.Path(path_type=Path),
     help="Directory containing the Robot Framework resource files.",
 )
+@click.option(
+    "--resource-directory-regex",
+    type=str,
+    help="""Regex that can be used to identify the TestBench
+    Subdivision that corresponds to the <resource-directory>.
+    Resources will be imported relative to this Subdivision
+    based on the test elements structure in TestBench.""",
+)
 @click.option(
     "--library-regex",
     multiple=True,
     type=str,
-    help="""Regex that can be used to identify TestBench
-         Subdivisions that correspond to Robot Framework libraries.""",
+    help="""Regular expression used to identify TestBench subdivisions
+    corresponding to Robot Framework libraries.""",
 )
 @click.option(
     "--library-root",
@@ -112,8 +123,8 @@ def testbench2robotframework_cli():
     "--resource-regex",
     multiple=True,
     type=str,
-    help="""Regex that can be used to identify TestBench Subdivisions
-         that correspond to Robot Framework resources.""",
+    help="""Regular expression used to identify TestBench subdivisions
+    corresponding to Robot Framework resources.""",
 )
 @click.option(
     "--resource-root",
@@ -126,13 +137,15 @@ def testbench2robotframework_cli():
     "--library-mapping",
     multiple=True,
     callback=parse_subdivision_mapping,
-    help="",
+    help="""Library import statement to use when a keyword from the
+    specified TestBench subdivision is encountered.""",
 )
 @click.option(
     "--resource-mapping",
     multiple=True,
     callback=parse_subdivision_mapping,
-    help="",
+    help="""Resource import statement to use when a keyword from the
+    specified TestBench subdivision is encountered.""",
 )
 @click.argument("testbench-report", type=click.Path(path_type=Path))
 def generate_tests(  # noqa: PLR0913
@@ -141,6 +154,7 @@ def generate_tests(  # noqa: PLR0913
     config: Path,
     fully_qualified: bool,
     library_regex: tuple[str],
+    resource_directory_regex: str,
     library_root: tuple[str],
     log_suite_numbering: bool,
     output_directory: Path,
@@ -180,7 +194,10 @@ def generate_tests(  # noqa: PLR0913
     configuration["resource-directory"] = (
         resource_directory.as_posix()
         if resource_directory
-        else configuration.get("resource-directory", "")
+        else configuration.get("resource-directory", "resources")
+    )
+    configuration["resource-directory-regex"] = resource_directory_regex or configuration.get(
+        "resource-directory-regex", DEFAULT_RESOURCE_DIRECTORY_REGEX
     )
     configuration["resource-mapping"] = resource_mapping or configuration.get(
         "resource-mapping", {}
@@ -216,11 +233,15 @@ def fetch_results(config: Path, robot_result: Path, output_directory: Path, test
 def get_tb2robot_file_configuration(config: Path) -> dict:
     if not config:
         pyproject_toml = find_pyproject_toml()
-    config_path = config or pyproject_toml
+        robot_toml = find_robot_toml()
+        private_robot_toml = find_private_robot_toml()
+        pyproject_config = get_testbench2robotframework_toml_dict(pyproject_toml)
+        robot_config = get_testbench2robotframework_toml_dict(robot_toml)
+        private_robot_config = get_testbench2robotframework_toml_dict(private_robot_toml)
+        return {**pyproject_config, **robot_config, **private_robot_config}
+    config_path = config
     if not config_path:
-        configuration = {}
-    elif config_path.suffix == ".json":
-        configuration = read_json(config, False)
-    else:
-        configuration = get_testbench2robotframework_toml_dict(config_path)
-    return configuration
+        return {}
+    if config_path.suffix == ".json":
+        return read_json(config, False)
+    return get_testbench2robotframework_toml_dict(config_path)

{testbench2robotframework-0.8.0a3 → testbench2robotframework-0.8.0a5}/testbench2robotframework/config.py

@@ -18,6 +18,7 @@ DEFAULT_LIBRARY_ROOTS: Final[list[str]] = ["RF", "RF-Library"]
 DEFAULT_RESOURCE_REGEX = r"(?:.*\.)?(?P<resourceName>[^.]+?)\s*\[Robot-Resource\].*"
 DEFAULT_RESOURCE_ROOTS: Final[list[str]] = ["RF-Resource"]
 DEFAULT_GENERATION_DIRECTORY = "{root}/Generated"
+DEFAULT_RESOURCE_DIRECTORY_REGEX = r".*\[Robot-Resources\].*"
 
 class StrEnum(str, Enum):
     def __new__(cls, *args):
@@ -41,6 +42,22 @@ def find_pyproject_toml() -> Path:
             return pyproject_path
     return Path()
 
+def find_robot_toml() -> Path:
+    current_dir = Path().cwd()
+    for parent in [current_dir, *list(current_dir.parents)]:
+        robot_path = parent / "robot.toml"
+        if robot_path.is_file():
+            return robot_path
+    return Path()
+
+def find_private_robot_toml() -> Path:
+    current_dir = Path().cwd()
+    for parent in [current_dir, *list(current_dir.parents)]:
+        private_robot_path = parent / ".robot.toml"
+        if private_robot_path.is_file():
+            return private_robot_path
+    return Path()
+
 
 def get_testbench2robotframework_toml_dict(toml_path: Path):
     try:
@@ -180,6 +197,7 @@ class Configuration:
     phasePattern: str
     referenceBehaviour: ReferenceBehaviour
     resource_directory: str
+    resource_directory_regex: str
     resource_regex: list[str]
     resource_root: list[str]
     subdivisionsMapping: SubdivisionsMapping
@@ -192,6 +210,8 @@ class Configuration:
             library_regex=dictionary.get(
                 "library-regex", [DEFAULT_LIBRARY_REGEX]
             ),
+            resource_directory_regex=dictionary.get(
+                "resource-directory-regex", DEFAULT_RESOURCE_DIRECTORY_REGEX),
             resource_regex=dictionary.get(
                 "resource-regex", [DEFAULT_RESOURCE_REGEX]
             ),
@@ -211,10 +231,10 @@ class Configuration:
             resource_directory=dictionary.get("resource-directory", "").replace(
                 "\\", "/"
             ),
-            testCaseSplitPathRegEx=dictionary.get("testCaseSplitPathRegEx", ".*StopWithRestart.*"),
+            testCaseSplitPathRegEx=dictionary.get("testcase-splitting-regex", ".*StopWithRestart.*"),
             phasePattern=dictionary.get("phasePattern", "{testcase} : Phase {index}/{length}"),
             referenceBehaviour=ReferenceBehaviour(
-                dictionary.get("referenceBehaviour", "ATTACHMENT").upper()
+                dictionary.get("reference-behaviour", "ATTACHMENT").upper()
             ),
             subdivisionsMapping=SubdivisionsMapping.from_dict(
                 {
@@ -223,7 +243,7 @@ class Configuration:
                 }
             ),
             attachmentConflictBehaviour=AttachmentConflictBehaviour(
-                dictionary.get("attachmentConflictBehaviour", "USE_EXISTING").upper()
+                dictionary.get("attachment-conflict-behaviour", "USE_EXISTING").upper()
             ),
         )
 

testbench2robotframework-0.8.0a5/testbench2robotframework/execution_artifacts.py

@@ -0,0 +1,245 @@
+import shutil
+import sys
+from pathlib import Path
+from typing import Optional
+from urllib.parse import unquote
+
+from .config import AttachmentConflictBehaviour, ReferenceBehaviour
+from .log import logger
+from .model import ReferenceAssignment, ReferenceKind
+
+FILE_URI_SCHEME = "file://"
+MEGABYTE = 1000 * 1000
+
+
+class ExecutionArtifactStorage:
+    def __init__(
+        self,
+        reference_behaviour: ReferenceBehaviour,
+        attachment_conflict_behaviour: AttachmentConflictBehaviour,
+        tb_references: list[ReferenceAssignment],
+        output_xml: str,
+        attachment_folder: str,
+    ):
+        self.reference_behaviour = reference_behaviour
+        self.attachmentConflictBehaviour = attachment_conflict_behaviour
+        self.tb_references: list[ReferenceAssignment] = tb_references
+        self.output_xml = output_xml
+        self.attachment_folder = attachment_folder
+        self._key: Optional[int] = None
+
+    def add_artifact(self, artifact: str) -> Optional[str]:
+        """
+        Adds an artifact to the storage based on the reference behaviour.
+
+        :param artifact: The artifact to add.
+        :type artifact: str
+        :return: The key of the added artifact or None if it could not be added.
+        :rtype: Optional[str]
+        """
+        artifact_value = self._dispatch_artifact_processing(artifact)
+        if not artifact_value:
+            return None
+        existing_artifact = self._get_existing_artifact(artifact_value, self.reference_behaviour)
+        if existing_artifact:
+            # if self.reference_behaviour == ReferenceBehaviour.ATTACHMENT:
+            #     self._handle_attachment_conflict(existing_artifact, artifact_value)
+            return existing_artifact.key
+        return self._add_new_reference(artifact_value, self.reference_behaviour)
+
+    @property
+    def new_key(self) -> int:
+        if self._key is not None:
+            self._key -= 1
+            return self._key
+        if not self.tb_references:
+            self._key = -4
+            return self._key
+        min_key = min([int(ref.key) for ref in self.tb_references])
+        starting_key_new_references = -3
+        self._key = (
+            min_key if min_key < starting_key_new_references else starting_key_new_references
+        )
+        self._key -= 1
+        return self._key
+
+    def _create_unique_attachment_path(self, attachement_path: Path) -> Path:
+        counter = 1
+        attachment_stem = attachement_path.stem
+        while attachement_path.exists():
+            attachement_path = Path(
+                f"{attachement_path.parent}",
+                f"{attachment_stem}_{counter}{attachement_path.suffix}",
+            )
+            counter += 1
+        return attachement_path
+
+    def _dispatch_attachment_copy(
+        self, filename: str, artifact_value: str, attachment_folder_path: Path
+    ) -> str:
+        conflict_methods = {
+            AttachmentConflictBehaviour.USE_NEW: (
+                self._use_new_attachment,
+                [filename, artifact_value, attachment_folder_path],
+            ),
+            AttachmentConflictBehaviour.RENAME_NEW: (
+                self._rename_new_attachment,
+                [filename, artifact_value, attachment_folder_path],
+            ),
+            AttachmentConflictBehaviour.USE_EXISTING: (self._use_existing_attachment, [filename]),
+            AttachmentConflictBehaviour.ERROR: (self._log_attachment_error, [filename]),
+        }
+        method, args = conflict_methods.get(
+            self.attachmentConflictBehaviour, (self._invalid_conflict_behaviour, [])
+        )
+        return method(*args)
+
+    def _use_new_attachment(
+        self, filename: str, artifact_value: str, attachment_folder_path: Path
+    ) -> str:
+        shutil.copyfile(artifact_value, attachment_folder_path / filename, follow_symlinks=True)
+        return filename
+
+    def _rename_new_attachment(
+        self, filename: str, artifact_value: str, attachment_folder_path: Path
+    ) -> str:
+        unique_path = self._create_unique_attachment_path(attachment_folder_path / filename)
+        unique_file = Path(unique_path).name
+        logger.info(
+            f"Attachment '{filename}' does already exist. "
+            f"Creating new unique attachment '{unique_file}'."
+        )
+        shutil.copyfile(artifact_value, unique_path, follow_symlinks=True)
+        return unique_file
+
+    def _use_existing_attachment(self, filename: str) -> str:
+        return filename
+
+    def _log_attachment_error(self, filename: str):
+        logger.error(f"Attachment '{filename}' does already exist.")
+        return filename
+
+    def _invalid_conflict_behaviour(self, filename: str):
+        logger.error(
+            f"Attachment conflict behaviour '{self.attachment_conflict_behaviour}' "
+            f"is not valid value. Please consult the documentation."
+        )
+        sys.exit()
+
+    def _copy_attachment(self, artifact_value: str) -> str:
+        filename = Path(artifact_value).name
+        attachment_folder_path = Path(self.attachment_folder)
+        if not attachment_folder_path.exists():
+            attachment_folder_path.mkdir(parents=True, exist_ok=True)
+        if not (attachment_folder_path / filename).exists():
+            return self._use_new_attachment(filename, artifact_value, attachment_folder_path)
+        return self._dispatch_attachment_copy(filename, artifact_value, attachment_folder_path)
+
+    def _process_artifact(self, artifact: str) -> Optional[str]:
+        artifact_info = ExecutionArtifactInfo(artifact, self.output_xml)
+        artifact_value = artifact_info.get_attachment_value()
+        if not artifact_value:
+            logger.warning(
+                f"Attachment '{artifact}' does not exist or can not be handled as an attachment."
+            )
+            return None
+        if not has_allowed_size(artifact_value):
+            logger.error(
+                f"Attachment '{artifact_value}' exceeds the maximum allowed size of 10 MB."
+            )
+            return None
+        return self._copy_attachment(artifact_value)
+
+    def _process_reference(self, artifact: str) -> Optional[str]:
+        artifact_info = ExecutionArtifactInfo(artifact, self.output_xml)
+        artifact_value = artifact_info.get_reference_value()
+        if not artifact_value:
+            logger.warning(
+                f"Reference '{artifact}' does not exist or can not be handled as a reference."
+            )
+            return None
+        return artifact_value
+
+    def _process_unknown(self, artifact: str) -> Optional[str]:
+        logger.error(
+            f"Unknown reference behaviour '{self.reference_behaviour}'."
+            f"Cannot add artifact '{artifact}'."
+        )
+        return None
+
+    def _process_no_references_allowed(self, artifact: str) -> Optional[str]:
+        logger.warning(
+            f"Reference behaviour is set to NONE."
+            f"Reference '{artifact}' will not be added to report."
+        )
+        return None
+
+    def _dispatch_artifact_processing(self, artifact):
+        artifact_processing_methods = {
+            ReferenceBehaviour.NONE: self._process_no_references_allowed,
+            ReferenceBehaviour.ATTACHMENT: self._process_artifact,
+            ReferenceBehaviour.REFERENCE: self._process_reference,
+        }
+        return artifact_processing_methods.get(self.reference_behaviour, self._process_unknown)(
+            artifact
+        )
+
+    def _add_new_reference(self, artifact_value: str, reference_behaviour: ReferenceBehaviour):
+        new_key = str(self.new_key)
+        self.tb_references.append(
+            ReferenceAssignment(
+                key=new_key,
+                value=artifact_value,
+                referenceType=ReferenceKind(reference_behaviour.capitalize()),
+            )
+        )
+        return new_key
+
+    def _get_existing_artifact(self, artifact_value: str, reference_behaviour: ReferenceBehaviour):
+        return next(
+            filter(
+                lambda ref: ref.value == artifact_value
+                and ref.referenceType.value.lower() == reference_behaviour.lower(),
+                self.tb_references,
+            ),
+            None,
+        )
+
+
+class ExecutionArtifactInfo:
+    def __init__(self, artifact: str, output_xml: str) -> None:
+        unquoted_artifact = unquote(artifact)
+        if unquoted_artifact.startswith(FILE_URI_SCHEME):
+            unquoted_artifact = unquoted_artifact[len(FILE_URI_SCHEME) :]
+        self.artifact = unquoted_artifact
+        self.output_xml = output_xml
+
+    def get_reference_value(self) -> Optional[str]:
+        unquoted_path = Path(self.artifact)
+        if not unquoted_path.exists():
+            robot_output_dir = Path(self.output_xml).parent
+            if Path(robot_output_dir, unquoted_path).exists():
+                unquoted_path = robot_output_dir / unquoted_path
+                unquoted_path = unquoted_path.resolve()
+            elif unquoted_path.is_absolute():
+                logger.warning(
+                    f"Referenced file '{unquoted_path}' does not exist."
+                    f"Reference will be attached anyway."
+                )
+            else:
+                return None
+        return str(unquoted_path)
+
+    def get_attachment_value(self) -> Optional[str]:
+        unquoted_path = Path(self.artifact)
+        if not unquoted_path.exists():
+            robot_output_dir = Path(self.output_xml).parent
+            if not Path(robot_output_dir, unquoted_path).exists():
+                return None
+            unquoted_path = robot_output_dir / unquoted_path
+        return str(unquoted_path)
+
+
+def has_allowed_size(file: str) -> bool:
+    file_size = Path.stat(Path(file)).st_size
+    return not file_size >= 10 * MEGABYTE

{testbench2robotframework-0.8.0a3 → testbench2robotframework-0.8.0a5}/testbench2robotframework/json_reader.py

@@ -7,6 +7,7 @@ from typing import Optional
 
 from .log import logger
 from .model import (
+    ReferenceAssignment,
     TestCaseDetails,
     TestCaseSetDetails,
     TestCaseSetNode,
@@ -94,6 +95,8 @@ class TestBenchJsonReader:
         for tcs_uid, tcs in self.test_case_sets.items():
             tc_catalog: dict[str, TestCaseDetails] = {}
             for tc_uid in self.get_test_case_uids(tcs_uid):
+                if tc_uid not in self.test_cases:
+                    continue
                 tc_catalog[tc_uid] = self.test_cases[tc_uid]
             tcs_catalog[tcs_uid] = TestCaseSet(tcs, tc_catalog)
         return tcs_catalog
@@ -132,6 +135,12 @@ class TestBenchJsonReader:
             return None
         return from_dict(TestStructureTree, test_structure_tree)
 
+    def read_references(self) -> list[ReferenceAssignment]:
+        references = read_json(str(Path(self.json_dir, "references.json")))
+        if references is None:
+            return []
+        return [from_dict(ReferenceAssignment, ref) for ref in references]
+
 
 def read_json(filepath: str, silent=True):
     try:

{testbench2robotframework-0.8.0a3 → testbench2robotframework-0.8.0a5}/testbench2robotframework/json_writer.py

@@ -7,6 +7,7 @@ from typing import Union
 from .config import Configuration
 from .log import logger
 from .model import (
+    ReferenceAssignment,
     TestCaseDetails,
     TestCaseSetDetails,
     TestCaseSetExecutionForImport,
@@ -45,6 +46,17 @@ def write_main_protocol(json_dir: str, main_protocol: list[TestCaseSetExecutionF
         )
 
 
+def write_references(json_dir: str, references: list[ReferenceAssignment]) -> None:
+    filepath = Path(json_dir) / Path("references.json")
+    with Path(filepath).open("w+", encoding="utf8") as output_file:
+        json.dump(
+            [asdict(ref) for ref in references],
+            output_file,
+            indent=2,
+            default=lambda o: o.value if isinstance(o, Enum) else str(o),
+        )
+
+
 def write_default_config(config_file):
     with Path(config_file).open("w+", encoding="utf-8") as file:
         json.dump(

{testbench2robotframework-0.8.0a3 → testbench2robotframework-0.8.0a5}/testbench2robotframework/model.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  openapi.yml
-#   timestamp: 2025-06-23T15:17:05+00:00
+#   timestamp: 2025-08-04T13:02:46+00:00
 
 from __future__ import annotations
 
@@ -828,6 +828,12 @@ class TestCaseDetailsOrigin(Enum):
     Upgraded = 'Upgraded'
 
 
+class ReferenceKind(Enum):
+    Reference = 'Reference'
+    Link = 'Link'
+    Attachment = 'Attachment'
+
+
 class TestFilterType(Enum):
     TestTheme = 'TestTheme'
     TestCaseSet = 'TestCaseSet'
@@ -1306,6 +1312,14 @@ class StringUDF(UDF):
     pass
 
 
+@dataclass
+class ReferenceAssignment:
+    key: str
+    value: str
+    referenceType: ReferenceKind
+    versionName: Optional[str] = None
+
+
 @dataclass
 class ParameterSummary:
     definitionType: ParameterDefinitionType
@@ -1324,7 +1338,6 @@ class AssignedDefect:
     id: str
     description: str
     identicalVersionKey: str
-    tester: str
     status: str
     priority: str
     classification: str
@@ -1332,6 +1345,7 @@ class AssignedDefect:
     references: List[str]
     udfs: List[DefectAttribute]
     version: Optional[str] = None
+    tester: Optional[str] = None
     lastEditTime: Optional[str] = None
     lastEditorKey: Optional[str] = None
     defectManagementSystem: Optional[str] = None
@@ -1636,9 +1650,3 @@ class CycleForUpdate:
     status: Optional[ProjectStatus] = None
     testingIntelligence: Optional[bool] = None
     startDate: Optional[OptionalLocalDateTime] = None
-
-
-@dataclass
-class Reference:  # TODO: May be changed. Differs to OpenApi.YML
-    type: RepresentativeType
-    path: str

{testbench2robotframework-0.8.0a3 → testbench2robotframework-0.8.0a5}/testbench2robotframework/result_writer.py

@@ -7,16 +7,16 @@ import uuid
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from shutil import copytree
-from typing import Optional, Union
-from urllib.parse import unquote
+from typing import Optional
 
 from robot.result import Keyword, ResultVisitor, TestCase, TestSuite
 
 from testbench2robotframework.model_utils import from_dict
 
-from .config import AttachmentConflictBehaviour, Configuration, ReferenceBehaviour
+from .config import Configuration
+from .execution_artifacts import ExecutionArtifactStorage
 from .json_reader import TestBenchJsonReader
-from .json_writer import write_main_protocol, write_test_structure_element
+from .json_writer import write_main_protocol, write_references, write_test_structure_element
 from .log import logger
 from .model import (
     ActivityStatus,
@@ -27,8 +27,6 @@ from .model import (
     InteractionCallExecution,
     InteractionType,
     InteractionVerdict,
-    Reference,
-    RepresentativeType,
     RichTextForImport,
     SequencePhase,
     TestCaseDetails,
@@ -37,7 +35,7 @@ from .model import (
     TestCaseSetExecutionForImport,
     VerdictStatus,
 )
-from .utils import directory_to_zip, ensure_dir_exists, get_directory
+from .utils import directory_to_zip, get_directory
 
 try:
     from robot.result import Group
@@ -62,6 +60,7 @@ COLOR = {
 }
 
 MEGABYTE = 1000 * 1000
+TB_ARTIFACT_REGEX = r"itb-reference:\s*(\S*)"
 
 
 class ResultWriter(ResultVisitor):
@@ -92,9 +91,7 @@ class ResultWriter(ResultVisitor):
                 copytree(self.json_dir, self.json_result, dirs_exist_ok=True)
         self.json_reader = TestBenchJsonReader(self.json_dir)
         self.attachments_path = Path(self.json_result, "attachments")
-        # if self.attachments_path.exists():  TODO: RR Sollten wir löschen????
-        #     shutil.rmtree(self.attachments_path)
-        # os.mkdir(self.attachments_path)
+        self.artifact_storage = self._create_artifact_storage()
         self.test_suites: dict[str, TestSuite] = {}
         self.keywords: list[Keyword] = []
         self.itb_test_case_catalog: dict[str, TestCaseDetails] = {}
@@ -102,6 +99,15 @@ class ResultWriter(ResultVisitor):
         self.test_chain: list[TestCase] = []
         self.main_protocol = from_dict(ExecutionImportingSuccess, {"testCaseSets": []})
 
+    def _create_artifact_storage(self):
+        return ExecutionArtifactStorage(
+            self.reference_behaviour,
+            self.attachment_conflict_behaviour,
+            self.json_reader.read_references(),
+            self.output_xml,
+            self.attachments_path.as_posix(),
+        )
+
     def start_suite(self, suite: TestSuite):
         if suite.metadata:
             self.test_suites[suite.metadata["uniqueID"]] = suite
@@ -114,11 +120,6 @@ class ResultWriter(ResultVisitor):
             if interaction.spec.interactionType == interaction_type:
                 yield interaction
 
-    # def _propergate_sequence_phase(self, interaction: InteractionCall, sequence_phase):
-    #     for child in interaction.interactions:
-    #         child.spec.sequencePhase = sequence_phase
-    #         self._propergate_sequence_phase(child, sequence_phase)
-
     def end_test(self, test: TestCase):
         self._test_setup_passed = None
         test_chain = get_test_chain(test.name, self.phase_pattern)
@@ -137,8 +138,6 @@ class ResultWriter(ResultVisitor):
         if not itb_test_case:
             logger.warning(f"No JSON file corresponding to test '{test_uid}' found in report.")
             return
-        # for interaction in itb_test_case.testSequence:
-        #     self._propergate_sequence_phase(interaction, interaction.spec.sequencePhase)
         self.protocol_test_case: TestCaseExecutionForImport = TestCaseExecutionForImport(
             test_uid, itb_test_case.exec.key, None, None, None
         )
@@ -163,8 +162,7 @@ class ResultWriter(ResultVisitor):
                 )
             self._set_itb_testcase_execution_result(itb_test_case, self.test_chain)
             self._set_itb_testcase_execution_comment(itb_test_case, self.test_chain)
-            if self.reference_behaviour != ReferenceBehaviour.NONE:
-                self._set_itb_testcase_references(itb_test_case, self.test_chain)
+            self._set_itb_testcase_references(itb_test_case, self.test_chain)
         except TypeError as e:
             logger.error(
                 "Could not find an itb testcase that corresponds "
@@ -185,78 +183,14 @@ class ResultWriter(ResultVisitor):
         if not itb_test_case.exec:
             return
         for test in test_chain:
-            itb_references = self._get_itb_reference(test.message)
-            for reference in itb_references:
-                if reference not in itb_test_case.exec.references:
-                    itb_test_case.exec.references.append(reference)
-
-    def _get_itb_reference(self, test_message: str) -> list[Reference]:
-        references = []
-        for path in re.findall(r"itb-reference:\s*(\S*)", test_message):
-            if path.startswith("file:///"):
-                file_path = Path(unquote(path[len("file:///") :]))
-                output_dir = Path(self.output_xml).parent
-                if file_path.exists():
-                    reference_path = file_path
-                elif Path(output_dir, file_path).exists():
-                    reference_path = Path(output_dir, file_path)
-                else:
-                    if (
-                        file_path.is_absolute()
-                        and self.reference_behaviour == ReferenceBehaviour.REFERENCE
-                    ):
-                        references.append(self._create_reference(file_path))
-                    else:
-                        logger.warning(f"Referenced file '{file_path}' does not exist.")
-                    continue
-                file_size = Path.stat(reference_path).st_size
-                reference: Optional[Reference] = None
-                if file_size >= 10 * MEGABYTE:
-                    logger.error(
-                        f"Trying to attach file '{reference_path}'. "
-                        "Attachment file size must not exceed 10 MB "
-                        f"but is {file_size / MEGABYTE} MB."
-                    )
-                    reference = self._create_reference(reference_path.name)
-                else:
-                    reference = self._create_attachment(reference_path)
-                if reference:
-                    references.append(reference)
-            elif re.match(r"\S+://", path):
-                references.append(Reference(RepresentativeType.Hyperlink, path))
-            else:
-                logger.warning(f"Could not identify type of test message reference '{path}'.")
-        return references
+            reference_values = self._get_itb_reference_values(test.message)
+            for reference_value in reference_values:
+                reference_key = self.artifact_storage.add_artifact(reference_value)
+                if reference_key and reference_key not in itb_test_case.exec.references:
+                    itb_test_case.exec.references.append(reference_key)
 
-    @staticmethod
-    def _create_reference(reference_path: Union[Path, str]) -> Reference:
-        return Reference(RepresentativeType.Reference, str(reference_path))
-
-    def _create_attachment(self, filepath: Path) -> Optional[Reference]:
-        if self.reference_behaviour == ReferenceBehaviour.REFERENCE:
-            return self._create_reference(filepath.resolve())
-        ensure_dir_exists(self.attachments_path)
-        filename = Path(filepath).name
-        if (
-            not Path(self.attachments_path, filename).exists()
-            or self.attachment_conflict_behaviour == AttachmentConflictBehaviour.USE_NEW
-        ):
-            shutil.copyfile(filepath, self.attachments_path / filename, follow_symlinks=True)
-            return Reference(RepresentativeType.Attachment, f"attachments/{filename}")
-        if self.attachment_conflict_behaviour == AttachmentConflictBehaviour.USE_EXISTING:
-            return Reference(RepresentativeType.Attachment, f"attachments/{filename}")
-        if self.attachment_conflict_behaviour == AttachmentConflictBehaviour.RENAME_NEW:
-            unique_path = self._create_unique_path(self.attachments_path / filename)
-            shutil.copyfile(filepath, unique_path, follow_symlinks=True)
-            unique_file = Path(unique_path).name
-            logger.info(
-                f"Attachment '{filename}' does already exist. "
-                f"Creating new unique attachment '{unique_file}'."
-            )
-            return Reference(RepresentativeType.Attachment, f"attachments/{unique_file}")
-        if self.attachment_conflict_behaviour == AttachmentConflictBehaviour.ERROR:
-            logger.error(f"Attachment '{filename}' does already exist.")
-        return None
+    def _get_itb_reference_values(self, test_message: str) -> list[str]:
+        return re.findall(f".*{TB_ARTIFACT_REGEX}.*", test_message)
 
     @staticmethod
     def _create_unique_path(attachement_path: Path) -> Path:
@@ -273,7 +207,7 @@ class ResultWriter(ResultVisitor):
     def _set_itb_testcase_execution_comment(self, itb_test_case, test_chain: list[TestCase]):
         exec_comments = []
         for test in test_chain:
-            message = re.sub(r"\s*itb-reference:\s*(\S*)", "", test.message)
+            message = re.sub(TB_ARTIFACT_REGEX, "", test.message)
             html_message = (
                 message[len("*HTML*") :].replace("<hr>", "<br/>").replace("<br>", "<br/>").strip()
                 if test.message.startswith("*HTML*")
@@ -597,7 +531,7 @@ class ResultWriter(ResultVisitor):
                 name = test.name
                 phase = ""
             if test.status != "PASS":
-                message = re.sub(r"\s*itb-reference:\s*(\S*)", "", test.message)
+                message = re.sub(TB_ARTIFACT_REGEX, "", test.message)
                 message = (
                     message[len("*HTML*") :]
                     .replace("<hr>", "<br />")
@@ -685,6 +619,7 @@ class ResultWriter(ResultVisitor):
                 test_suite_counter += 1
             write_test_structure_element(self.json_result, tt_tree)
             write_main_protocol(self.json_result, self.main_protocol.testCaseSets)
+            write_references(self.json_result, self.artifact_storage.tb_references)
             if test_suite_counter and self.itb_test_case_catalog:
                 logger.info(f"Successfully read {test_suite_counter} test suites.")
             else:

{testbench2robotframework-0.8.0a3 → testbench2robotframework-0.8.0a5}/testbench2robotframework/testbench2rf.py

@@ -125,6 +125,17 @@ class RfTestCase:
     def _get_interaction_call(self, test_step: InteractionCall) -> None:
         indent = len(test_step.numbering.split("."))
         if test_step.spec.interactionType == InteractionType.Textual:
+            self.rf_interaction_calls.append(
+                RFInteractionCall(
+                    name=f"# {test_step.spec.name}",
+                    cbv_parameters={},
+                    cbr_parameters={},
+                    indent=indent,
+                    import_prefix=None,
+                    sequence_phase=test_step.spec.sequencePhase,
+                    is_atomic=True,
+                )
+            )
             return
         cbv_params = self._get_params_by_use_type(test_step, ParameterEvaluationType.CallByValue)
         cbr_params = self._get_params_by_use_type(
@@ -180,22 +191,19 @@ class RfTestCase:
         for pattern in self.lib_pattern_list:
             match = pattern.search(interaction_path)
             if match:
-                return LIBRARY_IMPORT_TYPE, match[1].strip()
+                return LIBRARY_IMPORT_TYPE, match.group("resourceName").strip()
         for pattern in self.res_pattern_list:
             match = pattern.search(interaction_path)
             if match:
-                return RESOURCE_IMPORT_TYPE, match[1].strip()
-
-        ia_path_parts = interaction_path.split(".")
-        if len(ia_path_parts) == 1:
-            return UNKNOWN_IMPORT_TYPE, ia_path_parts[0]
-        root_subdivision, import_prefix = ia_path_parts[:2]
-        if root_subdivision in self.config.library_root:
-            return LIBRARY_IMPORT_TYPE, import_prefix
-        if root_subdivision in self.config.resource_root:
-            return RESOURCE_IMPORT_TYPE, import_prefix
-
-        return root_subdivision, import_prefix
+                return RESOURCE_IMPORT_TYPE, interaction_path
+        splitted_interaction_path = interaction_path.split(".")
+        minimum_length_subdivision_path_length = 2
+        if (
+            len(splitted_interaction_path) == minimum_length_subdivision_path_length
+            and splitted_interaction_path[0] in self.config.library_root
+        ):
+            return LIBRARY_IMPORT_TYPE, splitted_interaction_path[1]
+        return UNKNOWN_IMPORT_TYPE, interaction_path
 
     def _append_compound_ia(
         self,
@@ -436,6 +444,11 @@ class RfTestCase:
             filter(lambda parameter: parameter != "", interaction.cbr_parameters.values())
         )
         for index, parameter in enumerate(cbr_parameters):
+            if not parameter:
+                logger.warning(
+                    f"Interaction {interaction.name} has undefined CallByReference parameter value."
+                )
+                continue
             if not parameter.startswith("${"):
                 cbr_parameters[index] = f"${{{parameter}}}"
         return cbr_parameters
@@ -622,6 +635,7 @@ class RobotSuiteFileBuilder:
         test_case_section = TestCaseSection(header=SectionHeader.from_params(Token.TESTCASE_HEADER))
         robot_ast_test_cases = []
         for index, test_case in enumerate(self._rf_test_cases):
+            logger.debug(f"Processing test case: {test_case.uid}")
             robot_ast_test_cases.extend(test_case.to_robot_ast_test_cases())
             if index != len(self._rf_test_cases) - 1:
                 robot_ast_test_cases[-1].body.extend(LINE_SEPARATOR)
@@ -669,36 +683,53 @@ class RobotSuiteFileBuilder:
         }  # TODO Fix Paths to correct models
         return [ResourceImport.from_params(res) for res in sorted(resource_paths)]
 
-    def _create_resource_path(self, resource: str) -> str:
-        subdivision_mapping = self.config.subdivisionsMapping.resources.get(resource)
-        resource = re.sub(".resource", "", resource)
-        if not subdivision_mapping:
-            if not self.config.resource_directory:
-                return f"{resource}.resource"
-            if not re.match(RELATIVE_RESOURCE_INDICATOR, self.config.resource_directory):
-                return Path(self.config.resource_directory, f"{resource}.resource").as_posix()
-            generation_directory = self._replace_relative_resource_indicator(
-                self.config.output_directory
-            )
-            robot_file_path = Path(generation_directory) / self.tcs_path.parent
-            resource_directory = self._replace_relative_resource_indicator(
-                self.config.resource_directory
-            )
-            resource_import = (
-                Path(os.path.relpath(Path(resource_directory), robot_file_path))
-                / f"{resource}.resource"
+    def _get_resource_name(self, resource: str) -> str | None:
+        resource_path_part = resource.split(".")[-1]
+        for resource_regex in self.config.resource_regex:
+            resource_name_match = re.search(resource_regex, resource_path_part, flags=re.IGNORECASE)
+            if resource_name_match:
+                return resource_name_match.group("resourceName").strip()
+        return None
+
+    def _get_resource_directory_path_index(self, resource: str) -> int | None:
+        splitted_interaction_path = resource.split(".")
+        for index, part in enumerate(splitted_interaction_path):
+            resource_directory_match = re.match(
+                self.config.resource_directory_regex, part, flags=re.IGNORECASE
             )
-            return resource_import.as_posix()
-        root_path = Path(os.curdir).absolute()
-        subdivision_mapping = re.sub(
-            r"^{resourceDirectory}", self.config.resource_directory, subdivision_mapping
+            if resource_directory_match:
+                return index
+        return None
+
+    def _get_resource_path_index(self, resource: str) -> int | None:
+        return len(resource.split(".")) - 1 if resource else None
+
+    def _create_resource_path(self, resource: str) -> str:
+        splitted_interaction_path = resource.split(".")
+        resource_dir_index = self._get_resource_directory_path_index(resource)
+        resource_name = self._get_resource_name(resource)
+        resource_name_index = self._get_resource_path_index(resource)
+        cropped_interaction_path = []
+        if resource_dir_index is None:
+            return f"{resource_name}.resource"
+        cropped_interaction_path.extend(
+            splitted_interaction_path[resource_dir_index + 1 : resource_name_index]
+        )
+        resource_path = Path(
+            self.config.resource_directory,
+            *cropped_interaction_path,
+            f"{resource_name}.resource",
+        ).as_posix()
+        resource_path = self.config.subdivisionsMapping.resources.get(resource_name, resource_path)
+        resource_path = re.sub(
+            r"^{resourceDirectory}", self.config.resource_directory, resource_path
         )
-        subdivision_mapping = re.sub(
+        root_path = Path(os.curdir).absolute()
+        return re.sub(
             RELATIVE_RESOURCE_INDICATOR,
             str(root_path).replace("\\", "/"),
-            subdivision_mapping,
+            resource_path,
         )
-        return str(subdivision_mapping)
 
     def _replace_relative_resource_indicator(self, path: Path | str) -> str:
         root_path = Path(os.curdir).absolute()

{testbench2robotframework-0.8.0a3 → testbench2robotframework-0.8.0a5}/testbench2robotframework/utils.py

@@ -4,6 +4,7 @@ import sys
 from pathlib import Path, PurePath
 from typing import Optional
 from zipfile import ZipFile
+from .log import logger
 
 from testbench2robotframework.model import (
     RootNode,
@@ -45,6 +46,9 @@ class PathResolver:
         self.tt_paths = self._get_paths(self.tt_catalog)
 
     def _analyze_tree(self, test_theme_tree: TestStructureTree):
+        if not test_theme_tree.root:
+            logger.warning("Test Structure Tree contains no root node.")
+            return
         self.tree_dict[test_theme_tree.root.base.key] = test_theme_tree.root
         self._add_existing_tcs_to_catalog(test_theme_tree.root)
         for tse in test_theme_tree.nodes: