spl2-testing-framework 1.5.0__tar.gz → 1.5.1__tar.gz

{spl2_testing_framework-1.5.0 → spl2_testing_framework-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spl2-testing-framework
-Version: 1.5.0
+Version: 1.5.1
 Summary: SPL2 Testing Framework
 Home-page: https://github.com/splunk/spl2-testing-framework
 Keywords: SPL2 testing framework
@@ -207,8 +207,9 @@ This checks can be applied only to box tests, as assertions which are used in un
 performance. 
 
 ## Format all files
-To format all files, run:
+To format all files run:
 
 ```bash
 black spl2_testing_framework tests
 ```
+

{spl2_testing_framework-1.5.0 → spl2_testing_framework-1.5.1}/README.md

@@ -175,8 +175,8 @@ This checks can be applied only to box tests, as assertions which are used in un
 performance. 
 
 ## Format all files
-To format all files, run:
+To format all files run:
 
 ```bash
 black spl2_testing_framework tests
-```
+```

{spl2_testing_framework-1.5.0 → spl2_testing_framework-1.5.1}/pyproject.toml

@@ -15,7 +15,7 @@
 
 [tool.poetry]
 name = "spl2-testing-framework"
-version = "1.5.0"
+version = "1.5.1"
 description = "SPL2 Testing Framework"
 authors = ["mgazda-splunk <mgazda@splunk.com>"]
 readme = "README.md"

{spl2_testing_framework-1.5.0 → spl2_testing_framework-1.5.1}/spl2_testing_framework/tools/performance.py

@@ -38,7 +38,7 @@ class PerformanceCheck:
     PIPELINE_PATTERN = re.compile(
         r"(?P<fullmatch>"
         r"^\s*?\$pipeline\s*?=\s*?\|?\s*?from\s*?\$source\s*?"  # first line of pipeline
-        r"(.|\n)*?"  # anything in between
+        r"(.|\n)*"  # greedy: match everything up to the LAST into $destination
         r"(\|\s*?into\s*?\$destination)"  # last line of pipeline definition
         r")",
         flags=re.M | re.VERBOSE,
@@ -46,8 +46,8 @@ class PerformanceCheck:
 
     FUNCTION_PATTERN = re.compile(
         r"^(?P<fullmatch>"
-        r"(export\s+)?function\s+(?P<f_name>\S+)\((?P<source>\S+):"  # function header
-        r".*{\n\s+return\s+(\|\s+)?from\s+(?P=source)\n*"  # return statement
+        r"(export\s+)?function\s+(?P<f_name>\S+)\((?P<source>\$\w+)"  # function header (source may lack type)
+        r"[^{]*{\n\s+return\s+(\|\s+)?(?:from|FROM)\s+(?P=source)\n*"  # return statement
         r"(?P<statements>(.|\n)*?)"  # anything before closing bracket
         r"(?P<closing_bracket>^\s*})"  # closing bracket [ASSUMED IT'S IN THE NEW LINE]
         r")",
@@ -56,6 +56,20 @@ class PerformanceCheck:
 
     STATEMENT_PATTERN = re.compile(r"^(?P<lx>\s*?\|.*)$", re.M)
 
+    SCALAR_FUNCTION_PATTERN = re.compile(
+        r"^(?P<fullmatch>"
+        r"(?:export\s+)?function\s+(?P<f_name>\S+)\("
+        r"[^{]*{\n"
+        r"(?P<statements>[\s\S]*?)"
+        r"(?P<closing_bracket>^\s*})"
+        r")",
+        flags=re.M | re.VERBOSE,
+    )
+
+    SCALAR_STATEMENT_PATTERN = re.compile(
+        r"^(?P<lx>\s*(?:\$\w+\s*=(?!=)|return\s).+)$", re.M
+    )
+
     def __init__(self, test: Test):
         self._test = test
         self._performance_check_type = test.meta.get("performance", None)
@@ -135,13 +149,26 @@ class PerformanceCheck:
             output = copy(self.code_module)
 
             for timestamp_name, value, relative in calculated_diffs:
+                marker = f">>> {(value * 1000):.6f}ms [{relative:.2%}] <<< "
                 output = re.sub(
                     rf"\| eval {timestamp_name}=time\(\)",
-                    f">>> {(value * 1000):.6f}ms [{relative:.2%}] <<< ",
+                    marker,
+                    output,
+                )
+                output = re.sub(
+                    rf"^\${timestamp_name}\s*=\s*time\(\)\s*\n",
+                    marker,
                     output,
+                    flags=re.M,
                 )
 
             output = re.sub(r"\| eval _timestamp_\w+_\d{3}=time\(\)", r"", output)
+            output = re.sub(
+                r"^\$_timestamp_\w+_\d{3}\s*=\s*time\(\)\s*\n?",
+                r"",
+                output,
+                flags=re.M,
+            )
 
             _LOGGER.info(output)
 
@@ -154,7 +181,10 @@ class PerformanceCheck:
     def _save_output(self, output: str, event_number: int) -> None:
         """Save output to text file"""
         os.makedirs(self.OUTPUT_DIR, exist_ok=True)
-        filename = f"{self.OUTPUT_DIR}/performance_{self._test.name}_{event_number}_{datetime.now()}.txt"
+        safe_name = (
+            self._test.name.replace(os.sep, "_").replace("/", "_").replace("\\", "_")
+        )
+        filename = f"{self.OUTPUT_DIR}/performance_{safe_name}_{event_number}_{datetime.now()}.txt"
 
         with open(filename, "w") as f:
             f.write(output)
@@ -181,13 +211,18 @@ class PerformanceCheck:
             flags=re.M,
         )
 
-        code_module = re.sub(
-            r"(\|\s*?into\s*?\$destination)",
-            r"| eval _timestamp_perf_stop = time()"
-            r"| eval _timestamp_perf_exec = _timestamp_perf_stop - _timestamp_perf_start \1",
-            code_module,
-            flags=re.M,
-        )
+        pattern = re.compile(r"(\|\s*?into\s*?\$destination)", re.M)
+        matches = list(pattern.finditer(code_module))
+        if matches:
+            last = matches[-1]
+            replacement = (
+                "| eval _timestamp_perf_stop = time()"
+                "| eval _timestamp_perf_exec = _timestamp_perf_stop - _timestamp_perf_start "
+                + last.group(1)
+            )
+            code_module = (
+                code_module[: last.start()] + replacement + code_module[last.end() :]
+            )
 
         return code_module
 
@@ -196,6 +231,7 @@ class PerformanceCheck:
 
         functions = self.__parse_functions(code_module)
         pipeline = self.__parse_pipeline(code_module)
+        scalar_functions = self.__parse_scalar_functions(code_module)
 
         functions.append(pipeline)
 
@@ -203,14 +239,37 @@ class PerformanceCheck:
             new_function = self.__add_timestamps_to_function(f)
             code_module = code_module.replace(f["fullmatch"], new_function)
 
+        for f in scalar_functions:
+            new_function = self.__add_timestamps_to_scalar_function(f)
+            code_module = code_module.replace(f["fullmatch"], new_function)
+
+        code_module = self._preserve_timestamps_through_fields(code_module)
+
         return code_module
 
+    @staticmethod
+    def _preserve_timestamps_through_fields(code_module: str) -> str:
+        """Replace '| fields' keep-mode with a no-op so _timestamp_perf* fields are not stripped."""
+        return re.sub(
+            r"\|\s*fields\s+(?!-)(.+)",
+            r"| eval _perf_fields_preserved=1",
+            code_module,
+        )
+
     def __parse_functions(self, code_module: str) -> List[Dict]:
         """Parse all functions from code module. The finding contains groups necessary for parsing it
         and adding timestamps"""
         functions = [m.groupdict() for m in self.FUNCTION_PATTERN.finditer(code_module)]
         return functions
 
+    def __parse_scalar_functions(self, code_module: str) -> List[Dict]:
+        """Parse scalar functions (no FROM $source) that use $variable = expr assignments."""
+        dataset_fn_names = {f["f_name"] for f in self.__parse_functions(code_module)}
+        all_fns = [
+            m.groupdict() for m in self.SCALAR_FUNCTION_PATTERN.finditer(code_module)
+        ]
+        return [f for f in all_fns if f["f_name"] not in dataset_fn_names]
+
     def __parse_pipeline(self, code_module: str) -> Dict:
         """Parse pipeline definition from code module. The finding contains groups necessary for parsing it
         and adding timestamps"""
@@ -249,3 +308,25 @@ class PerformanceCheck:
             )
 
         return new_function
+
+    def __add_timestamps_to_scalar_function(self, f: Dict) -> str:
+        """Add timestamps to scalar functions that use $variable = expr assignments.
+        Injects $-prefixed variable assignments instead of | eval commands."""
+        new_function = self.SCALAR_STATEMENT_PATTERN.sub(
+            rf"$_time_{f['f_name']}_placeholder = time()\n\g<lx>",
+            f["fullmatch"],
+        )
+
+        func_timestamps = re.findall(
+            rf"\$_time_{f['f_name']}_placeholder", new_function
+        )
+
+        for n, timestamp in enumerate(func_timestamps):
+            new_function = re.sub(
+                re.escape(timestamp),
+                rf"$_timestamp_perf{f['f_name']}_{n:03d}",
+                new_function,
+                count=1,
+            )
+
+        return new_function

{spl2_testing_framework-1.5.0 → spl2_testing_framework-1.5.1}/spl2_testing_framework/tools/spl2test_runner.py

@@ -177,6 +177,7 @@ class SPL2TestRunner:
             _LOGGER.debug("Expected: \n%s", str(box_test.output))
         else:
             _LOGGER.info(f"Output check skipped (expected empty): {box_test.name}")
+            _LOGGER.debug("Actual results received: \n%s", str(output_result))
 
         if box_test.metrics:
             # Remove fields from actual metrics that are not in expected metrics if configured