Use the MultiFileInputTool class in pkg tool (#513)

TannazVhdBMWExt · web-flow · commit b7517df73f1a · 2025-11-11T14:41:49.000+01:00
Using the predefined arguments in MultiFileInputTool class and modify
the system/unit tests accordingly
diff --git a/lobster/tools/pkg/pkg.py b/lobster/tools/pkg/pkg.py
@@ -16,21 +16,20 @@
 # You should have received a copy of the GNU Affero General Public
 # License along with this program. If not, see
 # <https://www.gnu.org/licenses/>.
-import os.path
 from pathlib import Path
 import sys
 import xml.etree.ElementTree as ET
 import json
 import re
-from typing import Dict, List, Optional, Sequence
+from typing import Dict, Optional, Sequence
 from xml.dom import minidom
 from argparse import Namespace
 
+from lobster.common.multi_file_input_config import Config
+from lobster.common.multi_file_input_tool import create_worklist, MultiFileInputTool
 from lobster.common.exceptions import LOBSTER_Exception
-from lobster.common.io import lobster_write
 from lobster.common.items import Activity, Tracing_Tag
 from lobster.common.location import File_Reference
-from lobster.common.meta_data_tool_base import MetaDataToolBase
 
 NS = {
     "ecu": "http://www.tracetronic.de/xml/ecu-test",
@@ -39,30 +38,6 @@
 TSBLOCK = "TsBlock"
 
 
-def get_valid_files(
-    file_dir: List[str]
-) -> List[str]:
-    file_list = []
-    for item in file_dir:
-        if os.path.isfile(item):
-            file_list.append(item)
-        elif os.path.isdir(item):
-            for path, _, files in os.walk(item):
-                for filename in files:
-                    _, ext = os.path.splitext(filename)
-                    if ext in (".pkg", ".ta"):
-                        file_list.append(os.path.join(path, filename))
-        else:
-            raise FileNotFoundError("%s is not a file or directory" % item)
-    return file_list
-
-
-def write_to_file(options: Namespace, data: Dict[str, Activity]) -> None:
-    with open(options.out, "w", encoding="UTF-8") as file:
-        lobster_write(file, Activity, "lobster-pkg", data.values())
-        print("Written output for %u items to %s" % (len(data), options.out))
-
-
 def create_raw_entry(
     data: Dict[str, Activity], file_name: str, trace_list: list
 ) -> None:
@@ -284,87 +259,93 @@ def extract_lobster_traces_from_trace_analysis(tree, filename):
     return valid_traces, misplaced_traces
 
 
-def lobster_pkg(options):
-    """
-    The main function to parse tracing information from .pkg files for LOBSTER.
+class PkgTool(MultiFileInputTool):
+    def __init__(self):
+        super().__init__(
+            name="pkg",
+            description="Extract tracing tags from pkg files for LOBSTER",
+            extensions=["pkg", "ta"],
+            official=True,
+        )
 
-    This function processes the input files or directories specified in 'options.files',
-    extracts tracing tags and activities from XML content (including both standard and
-    TRACE-ANALYSIS blocks), and writes the results to an output file
+    def _add_config_argument(self):
+        # This tool does not use a config file
+        pass
+
+    def lobster_pkg(self, options):
+        """
+        The main function to parse tracing information from .pkg files for LOBSTER.
+
+        This function processes the input files or directories specified in
+        'options.files', extracts tracing tags and activities from XML content
+        (including both standard and TRACE-ANALYSIS blocks), and writes the
+        results to an output file
+
+        Parameters
+        ----------
+            options (Namespace): Parsed command-line arguments with at least:
+                - dir_or_files: list of file or directory paths to process
+                - out: output file path (optional; if not set, output is report.lobster)
+        """
+        config = Config(
+            inputs=None,
+            inputs_from_file=None,
+            extensions=self._extensions,
+            exclude_patterns=None,
+            schema=Activity,
+        )
+        file_list = create_worklist(config, options.dir_or_files)
+        if not file_list:
+            raise ValueError("No input files found to process!")
 
-    Parameters
-    ----------
-        options (Namespace): Parsed command-line arguments with at least:
-            - files: list of file or directory paths to process
-            - out: output file path (optional; if not set, output is report.lobster)
-    """
-    file_list = get_valid_files(options.files)
-    data = {}
+        data = {}
 
-    for file_path in file_list:
-        filename = Path(file_path).name
-        with open(file_path, "r", encoding="UTF-8") as file:
-            try:
-                file_content = file.read()
+        for file_path in file_list:
+            filename = Path(file_path).name
+            with open(file_path, "r", encoding="UTF-8") as file:
+                try:
+                    file_content = file.read()
 
-                tree = ET.fromstring(file_content)
+                    tree = ET.fromstring(file_content)
 
-                getvalues = xml_parser(file_content, filename)
+                    getvalues = xml_parser(file_content, filename)
 
-                # Also extract from TRACE-ANALYSIS blocks
-                valid_traces, misplaced_traces = (
-                    extract_lobster_traces_from_trace_analysis(
-                        tree, filename
+                    # Also extract from TRACE-ANALYSIS blocks
+                    valid_traces, misplaced_traces = (
+                        extract_lobster_traces_from_trace_analysis(
+                            tree, filename
+                        )
                     )
-                )
-                getvalues.extend(valid_traces)
-                for msg in misplaced_traces:
-                    print(msg)
-
-                if getvalues:
-                    create_raw_entry(data, file.name, json.dumps(getvalues))
-                else:
-                    create_default_activity(file_content, filename, data)
-
-            except ET.ParseError as err:
-                print(f"Error parsing XML file '{filename}' : {err}")
-                raise
-            except LOBSTER_Exception as err:
-                err.dump()
-                raise
-
-    # Set default output file if not specified
-    output_file = getattr(options, "out", None)
-    if not output_file:
-        options.out = "report.lobster"
-
-    write_to_file(options, data)
-
-    return 0
-
-
-class PkgTool(MetaDataToolBase):
-    def __init__(self):
-        super().__init__(
-            name="pkg",
-            description="Extract tracing tags from pkg files for LOBSTER",
-            official=True,
-        )
-        self._argument_parser.add_argument(
-            "files",
-            nargs="+",
-            metavar="FILE|DIR",
-            help="Path to pkg file or directory.",
+                    getvalues.extend(valid_traces)
+                    for msg in misplaced_traces:
+                        print(msg)
+
+                    if getvalues:
+                        create_raw_entry(data, file.name, json.dumps(getvalues))
+                    else:
+                        create_default_activity(file_content, filename, data)
+
+                except ET.ParseError as err:
+                    print(f"Error parsing XML file '{filename}' : {err}")
+                    raise
+                except LOBSTER_Exception as err:
+                    err.dump()
+                    raise
+
+        items = (
+            list(data.values())
+            if not isinstance(data.values(), list)
+            else data.values()
         )
-        self._argument_parser.add_argument(
-            "--out",
-            required=True,
-            help="write output to this file; otherwise output is report.lobster",
+        self._write_output(
+            schema=config.schema,
+            out_file=options.out,
+            items=items,
         )
 
     def _run_impl(self, options: Namespace) -> int:
         try:
-            lobster_pkg(options)
+            self.lobster_pkg(options)
             return 0
         except (ValueError, FileNotFoundError,
                 LOBSTER_Exception, ET.ParseError) as exception:
diff --git a/tests_system/lobster_pkg/lobster_pkg_asserter.py b/tests_system/lobster_pkg/lobster_pkg_asserter.py
@@ -10,5 +10,5 @@
 class LobsterPkgAsserter(Asserter):
     def assertStdOutNumAndFile(self, num_items: int, out_file: str):
         self.assertStdOutText(
-            f"Written output for {num_items} items to {out_file}\n"
+            f"lobster-pkg: wrote {num_items} items to {out_file}\n"
         )
diff --git a/tests_system/lobster_pkg/test_invalid_scenario.py b/tests_system/lobster_pkg/test_invalid_scenario.py
@@ -33,8 +33,8 @@ def test_missing_input_parameter(self):
 
         completed_process = self._test_runner.run_tool_test()
         asserter = LobsterPkgAsserter(self, completed_process, self._test_runner)
-        asserter.assertInStdErr('the following arguments are required: FILE|DIR')
-        asserter.assertExitCode(2)
+        asserter.assertInStdErr('lobster-pkg: No input files found to process!\n')
+        asserter.assertExitCode(1)
 
     def test_not_existing_output_path(self):
         """Test that a missing output path causes non-zero exit code"""
@@ -66,7 +66,7 @@ def test_misplaced_lobster_trace_file(self):
         expected_output = (
             'WARNING: misplaced lobster-trace in misplaced_lobster_trace.pkg: '
             'lobster-trace: misplaced.req1,misplaced.req2\n'
-            'Written output for 1 items to report.lobster\n'
+            'lobster-pkg: wrote 1 items to report.lobster\n'
         )
         asserter.assertStdOutText(expected_output)
         asserter.assertExitCode(0)
@@ -108,18 +108,6 @@ def test_invalid_xml_file(self):
         asserter.assertStdOutText(expected_output)
         asserter.assertExitCode(1)
 
-    def test_invalid_input_pkg_file_without_output_argument(self):
-        self._test_runner.cmd_args.files = [
-            str(self._data_directory / "valid_file1.pkg")
-        ]
-
-        completed_process = self._test_runner.run_tool_test()
-
-        asserter = LobsterPkgAsserter(self, completed_process, self._test_runner)
-
-        asserter.assertExitCode(2)
-        asserter.assertInStdErr("the following arguments are required: --out")
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests_system/lobster_pkg/test_valid_scenario.py b/tests_system/lobster_pkg/test_valid_scenario.py
@@ -76,7 +76,7 @@ def test_valid_ta_file_with_misplaced_traces(self):
             'lobster-trace:12345678\n'
             'WARNING: misplaced lobster-trace in with_misplaced_traces.ta: '
             'lobster-trace:98765432\n'
-            'Written output for 1 items to with_misplaced_traces.lobster\n'
+            'lobster-pkg: wrote 1 items to with_misplaced_traces.lobster\n'
         )
         asserter.assertExitCode(0)
 
@@ -103,7 +103,7 @@ def test_valid_pkg_file_with_misplaced_traces(self):
             'lobster-trace: misplaced.req1,misplaced.req2\n'
             'WARNING: misplaced lobster-trace in with_misplaced_traces.pkg: '
             'lobster-trace: misplaced.req3,misplaced.req4\n'
-            'Written output for 1 items to valid_file1.lobster\n'
+            'lobster-pkg: wrote 1 items to valid_file1.lobster\n'
         )
         asserter.assertExitCode(0)
 
diff --git a/tests_unit/lobster_pkg/data/sample_with_misplaced.pkg b/tests_unit/lobster_pkg/data/sample_with_misplaced.pkg
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PACKAGE format-rev="7" prog-version="2023.4.3.143937+fa3cbd256512" xmlns="http://www.tracetronic.de/xml/ecu-test" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.tracetronic.de/xml/ecu-test package.xsd">
+	<INFORMATION format-rev="2" xsi:type="packageInfo">
+		<TAGS>
+			<TAG xsi:type="string">TESTCASE</TAG>
+		</TAGS>
+		<DESCRIPTION xsi:type="string">&quot;RequirementTrace&quot;:  [
+                &quot;banana.reqE&quot;,
+                &quot;banana.reqF&quot;]</DESCRIPTION>
+		<VERSION xsi:type="string"/>
+		<ALTERNATE-CALL-REPRESENTATION-ACTION-FIELD-TEMPLATE xsi:type="string"/>
+		<ALTERNATE-CALL-REPRESENTATION-EXPECTATION-FIELD-TEMPLATE xsi:type="string"/>
+	</INFORMATION>
+    <TESTSTEPS xsi:type="testCase">
+        <TESTSTEP format-rev="3" id="1" name="TsBlock" xsi:type="utility-11111111111">
+            <VALUE xsi:type="string">lobster-trace: banana.reqA,banana.reqB</VALUE>
+            <TESTSTEP format-rev="3" id="2" name="TsBlock" xsi:type="utility-22222222222">
+                <VALUE xsi:type="string">lobster-trace: allowed.req1,allowed.req2</VALUE>
+                <TESTSTEP format-rev="3" id="3" name="TsBlock" xsi:type="utility-33333333333">
+                    <VALUE xsi:type="string">lobster-trace: misplaced.req1,misplaced.req2</VALUE>
+                </TESTSTEP>
+            </TESTSTEP>
+        </TESTSTEP>
+    </TESTSTEPS>
+    <TRACE-ANALYSIS>
+		<!-- Valid: DESCRIPTION is direct child of ANALYSISITEM (type=episode) -->
+		<ANALYSISITEM xsi:type="episode">
+			<NAME>Episode1</NAME>
+			<DESCRIPTION>lobster-trace: valid.req1,valid.req2</DESCRIPTION>
+		</ANALYSISITEM>
+		<!-- Misplaced: DESCRIPTION is nested inside another ANALYSISITEM -->
+		<ANALYSISITEM xsi:type="episode">
+			<NAME>Episode2</NAME>
+			<ANALYSISITEM xsi:type="other">
+				<DESCRIPTION>lobster-trace: misplaced.req1,misplaced.req2</DESCRIPTION>
+			</ANALYSISITEM>
+		</ANALYSISITEM>
+	</TRACE-ANALYSIS>
+</PACKAGE>
diff --git a/tests_unit/lobster_pkg/test_pkg.py b/tests_unit/lobster_pkg/test_pkg.py

Original file line number	Diff line number	Diff line change
`@@ -10,5 +10,5 @@`
`10`	`10`	`class LobsterPkgAsserter(Asserter):`
`11`	`11`	`def assertStdOutNumAndFile(self, num_items: int, out_file: str):`
`12`	`12`	`self.assertStdOutText(`
`13`		`- f"Written output for {num_items} items to {out_file}\n"`
	`13`	`+ f"lobster-pkg: wrote {num_items} items to {out_file}\n"`
`14`	`14`	`)`