synapse-hub 2.2.4 → 2.4.1

package/tools/generate_jmx_plan.py

@@ -18,7 +18,11 @@ Comprehensive 10/10 Pinnacle Performance Features:
      - RegexExtractor for HTML hidden CSRF / Anti-Forgery tokens
      - JSONPostProcessor with Match Number 0 (Random dynamic item choice avoiding duplicate lockups)
      - Chaining Bearer JWT token & entity IDs.
-  6. Workload Archetypes: Linear, Step-Up (Break-point), Spike, and Soak profiles.
+  6. Workload Archetypes: Linear, Step-Up (Break-point), Spike, and Soak profiles -
+     step/spike emit staged ThreadGroups (per-stage threads/ramp/hold/delay windows).
+  6b. Locust Code-as-Code Export (`--emit-locust`): generates a runnable
+      locustfile.py (User class + weighted @task endpoints) from the same
+      OpenAPI/Postman/HAR ingestion - concept borrowed from Locust (MIT).
   7. Enterprise Security: JSR223 Groovy HMAC-SHA256 payload signer & correlation IDs.
   8. Full-Stack Observability & Telemetry:
      - InfluxDB Backend Listener for live Grafana APM dashboard streaming
@@ -57,6 +61,40 @@ if hasattr(sys.stdout, "reconfigure"):
         pass
 
 
+def compute_workload_stages(workload_profile: str, vus: int, ramp_up: int, duration: int) -> List[Dict[str, int]]:
+    """Computes staged execution windows for step/spike profiles.
+
+    Each stage is a plain JMeter ThreadGroup with its own scheduler window
+    (threads, ramp, hold, delay) so staged load works on vanilla JMeter 5.x
+    without plugins. Linear/soak return a single stage (behavior unchanged).
+    """
+    if workload_profile == "step":
+        step_count = 4
+        per_step = max(1, (vus + step_count - 1) // step_count)
+        window_ramp = max(1, min(10, ramp_up))
+        window_hold = max(30, duration // step_count)
+        stages = []
+        for i in range(step_count):
+            threads = min(per_step * (i + 1), vus)
+            stages.append({"threads": threads, "ramp": window_ramp,
+                           "hold": window_hold, "delay": i * (window_ramp + window_hold)})
+        return stages
+
+    if workload_profile == "spike":
+        base = max(1, round(vus * 0.2))
+        base_hold = max(10, round(duration * 0.7))
+        spike_hold = max(10, round(duration * 0.15))
+        tail_hold = max(10, duration - base_hold - spike_hold)
+        return [
+            {"threads": base, "ramp": ramp_up, "hold": base_hold, "delay": 0},
+            {"threads": vus, "ramp": 5, "hold": spike_hold, "delay": base_hold},
+            {"threads": base, "ramp": 5, "hold": tail_hold, "delay": base_hold + spike_hold},
+        ]
+
+    # linear / soak: single continuous stage (legacy behavior, property-overridable)
+    return [{"threads": vus, "ramp": ramp_up, "hold": duration, "delay": 0}]
+
+
 def build_jmx_xml(
     plan_name: str,
     base_host: str,
@@ -351,23 +389,46 @@ def build_jmx_xml(
     if workload_profile == "soak" and duration < 3600:
         actual_duration = 3600  # Default 1h for soak
 
-    xml_lines.extend([
-        f'      <!-- Main Thread Group: {workload_profile.upper()} Profile -->',
-        f'      <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="{tg_name}" enabled="true">',
-        '        <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>',
-        '        <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">',
-        f'          <boolProp name="LoopController.continue_forever">{continue_forever}</boolProp>',
-        f'          <stringProp name="LoopController.loops">${{__P(loops,{loops_str})}}</stringProp>',
-        '        </elementProp>',
-        f'        <stringProp name="ThreadGroup.num_threads">${{__P(vus,{vus})}}</stringProp>',
-        f'        <stringProp name="ThreadGroup.ramp_time">${{__P(ramp_up,{ramp_up})}}</stringProp>',
-        '        <boolProp name="ThreadGroup.scheduler">true</boolProp>',
-        f'        <stringProp name="ThreadGroup.duration">${{__P(duration,{actual_duration})}}</stringProp>',
-        '        <stringProp name="ThreadGroup.delay">0</stringProp>',
-        '        <boolProp name="ThreadGroup.same_user_on_next_iteration">true</boolProp>',
-        '      </ThreadGroup>',
-        '      <hashTree>'
-    ])
+    stages = compute_workload_stages(workload_profile, vus, ramp_up, actual_duration)
+    is_staged = len(stages) > 1
+
+    def _emit_stage_group(stage: Dict[str, int], stage_index: int) -> None:
+        """Emits one stage ThreadGroup header. Single-stage plans keep the
+        legacy property-overridable form (${__P(vus,...)}); staged plans use
+        concrete per-stage windows."""
+        name = tg_name if not is_staged else f"{tg_name} - Stage {stage_index + 1}"
+        if is_staged:
+            threads_prop = str(stage["threads"])
+            ramp_prop = str(stage["ramp"])
+            duration_prop = str(stage["hold"])
+            delay_prop = str(stage["delay"])
+            header = f'      <!-- Workload Stage {stage_index + 1}/{len(stages)}: {stage["threads"]} VUs, ramp {stage["ramp"]}s, hold {stage["hold"]}s, delay {stage["delay"]}s -->'
+        else:
+            threads_prop = f'${{__P(vus,{stage["threads"]})}}'
+            ramp_prop = f'${{__P(ramp_up,{stage["ramp"]})}}'
+            duration_prop = f'${{__P(duration,{stage["hold"]})}}'
+            delay_prop = "0"
+            header = f'      <!-- Main Thread Group: {workload_profile.upper()} Profile -->'
+        xml_lines.extend([
+            header,
+            f'      <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="{name}" enabled="true">',
+            '        <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>',
+            '        <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">',
+            f'          <boolProp name="LoopController.continue_forever">{continue_forever}</boolProp>',
+            f'          <stringProp name="LoopController.loops">${{__P(loops,{loops_str})}}</stringProp>',
+            '        </elementProp>',
+            f'        <stringProp name="ThreadGroup.num_threads">{threads_prop}</stringProp>',
+            f'        <stringProp name="ThreadGroup.ramp_time">{ramp_prop}</stringProp>',
+            '        <boolProp name="ThreadGroup.scheduler">true</boolProp>',
+            f'        <stringProp name="ThreadGroup.duration">{duration_prop}</stringProp>',
+            f'        <stringProp name="ThreadGroup.delay">{delay_prop}</stringProp>',
+            '        <boolProp name="ThreadGroup.same_user_on_next_iteration">true</boolProp>',
+            '      </ThreadGroup>',
+            '      <hashTree>'
+        ])
+
+    _emit_stage_group(stages[0], 0)
+    stage_body_start = len(xml_lines)
 
     # CSV Data Set Config (Dynamic credentials / entities)
     if csv_file:
@@ -677,47 +738,60 @@ def build_jmx_xml(
             '        <hashTree/>'
         ])
 
-    # Result Collectors for CLI JTL export and Summary
+    # Capture the first stage's hashTree body, close it, then replicate it for
+    # the remaining staged profiles (step/spike) so every stage executes the
+    # full sampler set inside its own scheduler window (vanilla JMeter, no
+    # plugins). The Result Collector moves to Test-Plan level so all stages
+    # stream into one JTL file.
+    stage_body = xml_lines[stage_body_start:]
+    xml_lines.append('      </hashTree>')
+
+    for stage_idx in range(1, len(stages)):
+        _emit_stage_group(stages[stage_idx], stage_idx)
+        xml_lines.extend(stage_body)
+        xml_lines.append('      </hashTree>')
+
+    # Result Collectors for CLI JTL export and Summary (plan-level: one JTL
+    # across all workload stages)
     xml_lines.extend([
-        '        <!-- Headless JTL Result Collector & Summary Report -->',
-        '        <ResultCollector guiclass="SummaryReport" testclass="ResultCollector" testname="Summary Report" enabled="true">',
-        '          <boolProp name="ResultCollector.error_logging">false</boolProp>',
-        '          <objProp>',
-        '            <name>saveConfig</name>',
-        '            <value class="SampleSaveConfiguration">',
-        '              <time>true</time>',
-        '              <latency>true</latency>',
-        '              <timestamp>true</timestamp>',
-        '              <success>true</success>',
-        '              <label>true</label>',
-        '              <code>true</code>',
-        '              <message>true</message>',
-        '              <threadName>true</threadName>',
-        '              <dataType>true</dataType>',
-        '              <encoding>false</encoding>',
-        '              <assertions>true</assertions>',
-        '              <subresults>true</subresults>',
-        '              <responseData>false</responseData>',
-        '              <samplerData>false</samplerData>',
-        '              <xml>false</xml>',
-        '              <fieldNames>true</fieldNames>',
-        '              <responseHeaders>false</responseHeaders>',
-        '              <requestHeaders>false</requestHeaders>',
-        '              <responseDataOnError>false</responseDataOnError>',
-        '              <saveAssertionResultsFailureMessage>true</saveAssertionResultsFailureMessage>',
-        '              <assertionsResultsToSave>0</assertionsResultsToSave>',
-        '              <bytes>true</bytes>',
-        '              <sentBytes>true</sentBytes>',
-        '              <url>true</url>',
-        '              <threadCounts>true</threadCounts>',
-        '              <idleTime>true</idleTime>',
-        '              <connectTime>true</connectTime>',
-        '            </value>',
-        '          </objProp>',
-        '          <stringProp name="filename">jmeter_results.jtl</stringProp>',
-        '        </ResultCollector>',
-        '        <hashTree/>',
-        '      </hashTree>',
+        '      <!-- Headless JTL Result Collector & Summary Report (plan-level, all stages) -->',
+        '      <ResultCollector guiclass="SummaryReport" testclass="ResultCollector" testname="Summary Report" enabled="true">',
+        '        <boolProp name="ResultCollector.error_logging">false</boolProp>',
+        '        <objProp>',
+        '          <name>saveConfig</name>',
+        '          <value class="SampleSaveConfiguration">',
+        '            <time>true</time>',
+        '            <latency>true</latency>',
+        '            <timestamp>true</timestamp>',
+        '            <success>true</success>',
+        '            <label>true</label>',
+        '            <code>true</code>',
+        '            <message>true</message>',
+        '            <threadName>true</threadName>',
+        '            <dataType>true</dataType>',
+        '            <encoding>false</encoding>',
+        '            <assertions>true</assertions>',
+        '            <subresults>true</subresults>',
+        '            <responseData>false</responseData>',
+        '            <samplerData>false</samplerData>',
+        '            <xml>false</xml>',
+        '            <fieldNames>true</fieldNames>',
+        '            <responseHeaders>false</responseHeaders>',
+        '            <requestHeaders>false</requestHeaders>',
+        '            <responseDataOnError>false</responseDataOnError>',
+        '            <saveAssertionResultsFailureMessage>true</saveAssertionResultsFailureMessage>',
+        '            <assertionsResultsToSave>0</assertionsResultsToSave>',
+        '            <bytes>true</bytes>',
+        '            <sentBytes>true</sentBytes>',
+        '            <url>true</url>',
+        '            <threadCounts>true</threadCounts>',
+        '            <idleTime>true</idleTime>',
+        '            <connectTime>true</connectTime>',
+        '          </value>',
+        '        </objProp>',
+        '        <stringProp name="filename">jmeter_results.jtl</stringProp>',
+        '      </ResultCollector>',
+        '      <hashTree/>',
         '    </hashTree>',
         '  </hashTree>',
         '</jmeterTestPlan>'
@@ -726,6 +800,108 @@ def build_jmx_xml(
     return "\n".join(xml_lines)
 
 
+def generate_locustfile(
+    plan_name: str,
+    base_host: str,
+    protocol: str,
+    port: str,
+    samplers: List[Dict[str, Any]],
+    weighted_mix: Optional[str] = None,
+    think_time_min_ms: int = 0,
+    think_time_max_ms: int = 0,
+) -> str:
+    """Generates a runnable locustfile.py (code-as-code load model).
+
+    Concept borrowed from Locust (MIT): the plan becomes a User class with
+    weighted @task endpoints, honoring the same --weighted-mix traffic shaping
+    as the JMX export (weights chunk the samplers sequentially).
+    """
+    host = f"{protocol}://{base_host}" if port in ("80", "443") else f"{protocol}://{base_host}:{port}"
+
+    # Distribute weights: chunk samplers sequentially per percentage.
+    task_weights: List[int] = [1] * len(samplers)
+    if weighted_mix:
+        try:
+            parts = [p.strip() for p in weighted_mix.split(",")]
+            pcts = [int(p.split(":")[0]) for p in parts if p]
+            total = sum(pcts) or 1
+            chunk = max(1, (len(samplers) + len(pcts) - 1) // len(pcts))
+            for gi, pct in enumerate(pcts):
+                for si in range(gi * chunk, min((gi + 1) * chunk, len(samplers))):
+                    task_weights[si] = max(1, round(pct * 10 / total))
+        except ValueError:
+            task_weights = [1] * len(samplers)
+
+    def _slug(name: str, idx: int) -> str:
+        words = re.sub(r"[^a-zA-Z0-9]+", "_", name).strip("_").lower() or f"endpoint_{idx}"
+        return f"task_{idx + 1:02d}_{words[:40]}"
+
+    def _locust_body(raw: str) -> str:
+        """Converts JMeter placeholders into a runtime-safe .format() body."""
+        if not raw:
+            return ""
+        s = raw.replace("${__time(HMS,)}", "\x01ts\x01")
+        s = s.replace("${RANDOM_ITEM_ID}", "\x01rnd\x01")
+        s = s.replace("${LAST_CREATED_ID}", "\x01last_id\x01")
+        s = re.sub(r"\$\{([A-Za-z0-9_]+)\}", lambda m: "sample_" + m.group(1).lower(), s)
+        s = s.replace("{", "{{").replace("}", "}}")
+        s = s.replace("\x01ts\x01", "{ts}").replace("\x01rnd\x01", "{rnd}").replace("\x01last_id\x01", "{last_id}")
+        return s
+
+    method_lines: List[str] = []
+    for idx, s in enumerate(samplers):
+        fn = _slug(s.get("name", f"{s.get('method')} {s.get('path')}"), idx)
+        weight = task_weights[idx] if idx < len(task_weights) else 1
+        method = (s.get("method") or "GET").upper()
+        path = (s.get("path") or "/").replace('"', '\\"')
+        method_lines.append(f"    @task({weight})")
+        method_lines.append(f"    def {fn}(self):")
+        method_lines.append(f'        """{s.get("name", method + " " + path)}"""')
+        if method in ("POST", "PUT", "PATCH"):
+            method_lines.append(
+                f'        self.client.{method.lower()}("{path}", '
+                f'name="{method} {path}", '
+                f'json=json.loads(BODIES["{fn}"].format(ts=datetime.now(timezone.utc).strftime("%H%M%S"), rnd=random.randint(1, 9999), last_id=LAST_CREATED_ID)))'
+            )
+        else:
+            method_lines.append(f'        self.client.get("{path}", name="{method} {path}")')
+        method_lines.append("")
+
+    think_time = (
+        f"between({think_time_min_ms / 1000:.2f}, {think_time_max_ms / 1000:.2f})"
+        if think_time_max_ms > 0
+        else "constant_pacing(1.0)"
+    )
+
+    bodies = "\n".join(
+        f'    "{_slug(s.get("name", ""), i)}": {_locust_body(s.get("body", ""))!r},'
+        for i, s in enumerate(samplers)
+        if (s.get("method") or "").upper() in ("POST", "PUT", "PATCH")
+    )
+
+    class_name = re.sub(r"[^A-Za-z0-9]+", "", plan_name.title()) or "EnterpriseUser"
+
+    return (
+        '"""Generated by Synapse Hub tools/generate_jmx_plan.py --emit-locust\n'
+        "Code-as-code load model (concept borrowed from Locust, MIT).\n"
+        "Run: locust -f this_file.py --host=HOST\n"
+        '"""\n'
+        "import json\n"
+        "import random\n"
+        "from datetime import datetime, timezone\n\n"
+        "from locust import HttpUser, task, between, constant_pacing\n\n"
+        "LAST_CREATED_ID = 1\n\n"
+        "BODIES = {\n"
+        f"{bodies}\n"
+        "}\n\n\n"
+        f"class {class_name}(HttpUser):\n"
+        f'    """{plan_name}"""\n\n'
+        f"    host = \"{host}\"\n"
+        f"    wait_time = {think_time}\n\n"
+        + "\n".join(method_lines)
+    )
+
+
 def parse_openapi_for_jmeter(spec_data: Dict[str, Any]) -> tuple:
     """Extracts base configuration and samplers list from OpenAPI spec."""
     info_dict = spec_data.get("info", {})
@@ -929,6 +1105,7 @@ def main():
     parser.add_argument("--loop-count", type=int, default=-1, help="Loop iterations count (-1 for infinite). Default: -1.")
     parser.add_argument("--sla-p95", type=int, default=500, help="P95 Latency SLA assertion threshold in ms. Default: 500.")
     parser.add_argument("--output", "-o", help="Target output JMeter test plan file path (.jmx).")
+    parser.add_argument("--emit-locust", dest="emit_locust", help="Also/instead emit a runnable Locust locustfile.py (code-as-code load model).")
     parser.add_argument("--sample", action="store_true", help="Generate a sample load test plan using built-in enterprise schema.")
     
     # Advanced JMeter 360° Extensions
@@ -1039,6 +1216,28 @@ def main():
         else:
             base_host = args.base_url
 
+    # Code-as-code Locust export (concept borrowed from Locust, MIT)
+    if args.emit_locust:
+        locust_source = generate_locustfile(
+            plan_name=plan_name,
+            base_host=base_host,
+            protocol=protocol,
+            port=port,
+            samplers=samplers,
+            weighted_mix=args.weighted_mix,
+            think_time_min_ms=args.think_time_min,
+            think_time_max_ms=args.think_time_max,
+        )
+        out_dir = os.path.dirname(os.path.abspath(args.emit_locust))
+        if out_dir and not os.path.exists(out_dir):
+            os.makedirs(out_dir, exist_ok=True)
+        with open(args.emit_locust, "w", encoding="utf-8") as f:
+            f.write(locust_source)
+        print(f"🐍 [LOCUST EXPORT] Runnable locustfile written: {args.emit_locust}")
+        print(f"   Run: locust -f \"{args.emit_locust}\" --host={protocol}://{base_host}:{port}")
+        if not args.output:
+            return
+
     jmx_content = build_jmx_xml(
         plan_name=plan_name,
         base_host=base_host,

package/tools/generate_test_reports.ps1

@@ -1,135 +1,13 @@
-# PowerShell Script to ensure TestReports and summaryTemp.txt for CI/CD Dashboard
-param(
-    [string]$ProjectName = "Enterprise-Automation"
-)
-
-[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
-Write-Host "=== [Centralize CI/CD] Generating TestReports & summaryTemp.txt for $ProjectName ===" -ForegroundColor Cyan
-
-$testReportsDir = Join-Path $PSScriptRoot "..\TestReports"
-$reportsDir = Join-Path $PSScriptRoot "..\Reports"
-
-if (-not (Test-Path $testReportsDir)) {
-    New-Item -ItemType Directory -Path $testReportsDir -Force | Out-Null
-}
-
-$passed = 0
-$failures = 0
-$errors = 0
-$incomplete = 0
-$skipped = 0
-$foundExistingSummary = $false
-
-# 0. Check if Cleanup_Browser already exported summaryTemp.txt with business test case counts
-$existingSummaryFile = Join-Path $reportsDir "summaryTemp.txt"
-if (-not (Test-Path $existingSummaryFile)) {
-    $existingSummaryFile = Join-Path $testReportsDir "summaryTemp.txt"
-}
-if (Test-Path $existingSummaryFile) {
-    try {
-        $rawSummary = [System.IO.File]::ReadAllText($existingSummaryFile, [System.Text.Encoding]::UTF8)
-        if ($rawSummary -match "(\d+)\s+Passed\s+-\s+.*?(\d+)\s+Failures\s+-\s+.*?(\d+)\s+Errors") {
-            $passed = [int]$matches[1]
-            $failures = [int]$matches[2]
-            $errors = [int]$matches[3]
-            if ($passed -gt 0) {
-                $foundExistingSummary = $true
-                Write-Host "[+] Found valid summaryTemp.txt from Cleanup_Browser: $rawSummary" -ForegroundColor Green
-            }
-        }
-    } catch {}
-}
-
-# 1. Find the latest report directory (check Reports, then TestReports)
-$latestReport = Get-ChildItem -Path @($reportsDir, $testReportsDir) -Recurse -Filter "*junit*.xml" -ErrorAction SilentlyContinue |
-    Sort-Object LastWriteTime -Descending | Select-Object -First 1
-
-if (-not $foundExistingSummary -and $latestReport) {
-    Write-Host "[+] Found latest JUnit report: $($latestReport.FullName)" -ForegroundColor Green
-    try {
-        [xml]$xml = Get-Content $latestReport.FullName
-        if ($xml.testsuites) {
-            $passed = [int]($xml.testsuites.passed)
-            $failures = [int]($xml.testsuites.failures)
-            $errors = [int]($xml.testsuites.errors)
-            $incomplete = [int]($xml.testsuites.incompleted)
-            $skipped = [int]($xml.testsuites.skipped)
-        } elseif ($xml.testsuite) {
-            $tests = [int]($xml.testsuite.tests)
-            $failures = [int]($xml.testsuite.failures)
-            $errors = [int]($xml.testsuite.errors)
-            $skipped = [int]($xml.testsuite.skipped)
-            $passed = [Math]::Max(0, $tests - $failures - $errors - $skipped)
-        }
-        $foundExistingSummary = $true
-    } catch {
-        Write-Warning "[!] Failed to parse XML: $_"
-    }
-}
-
-if (-not $foundExistingSummary) {
-    # Fallback to console0.log
-    $latestLog = Get-ChildItem -Path @($reportsDir, $testReportsDir) -Recurse -Filter "console0.log" -ErrorAction SilentlyContinue |
-        Sort-Object LastWriteTime -Descending | Select-Object -First 1
-
-    if ($latestLog) {
-        Write-Host "[+] Fallback: Parsing console log: $($latestLog.FullName)" -ForegroundColor Yellow
-        $logContent = Get-Content $latestLog.FullName -Raw
-        if ($logContent -match "Passed:\s*(\d+)\s*\|\s*Failed:\s*(\d+)\s*\|\s*Errors:\s*(\d+)") {
-            $passed = [int]$matches[1]
-            $failures = [int]$matches[2]
-            $errors = [int]$matches[3]
-        } elseif ($logContent -match "Tổng số:\s*(\d+)\s*\|\s*Đạt:\s*(\d+)\s*\|\s*Thất bại:\s*(\d+)\s*\|\s*Lỗi:\s*(\d+)") {
-            $passed = [int]$matches[2]
-            $failures = [int]$matches[3]
-            $errors = [int]$matches[4]
-        } else {
-            $passed = ([regex]::Matches($logContent, "\[TEST_CASE\]\[PASSED\]")).Count
-            $failures = ([regex]::Matches($logContent, "\[TEST_CASE\]\[FAILED\]")).Count
-            $errors = ([regex]::Matches($logContent, "\[TEST_CASE\]\[ERROR\]")).Count
-        }
-    }
-}
-
-Write-Host "[+] Metrics: Passed=$passed, Failures=$failures, Errors=$errors, Incomplete=$incomplete, Skipped=$skipped" -ForegroundColor Cyan
-
-# 2. Write summaryTemp.txt: \u2705 {P} Passed - \u274C {F} Failures - \u274C {E} Errors - \u2757 {I} Incomplete - \u26AA {S} Skipped
-$summaryContent = "\u2705 $passed Passed - \u274C $failures Failures - \u274C $errors Errors - \u2757 $incomplete Incomplete - \u26AA $skipped Skipped"
-
-$summaryFile = Join-Path $testReportsDir "summaryTemp.txt"
-[System.IO.File]::WriteAllText($summaryFile, $summaryContent, [System.Text.Encoding]::ASCII)
-Write-Host "[+] Created: $summaryFile" -ForegroundColor Green
-Write-Host "    $summaryContent"
-
-# Also write to Reports/summaryTemp.txt for fallback
-if (Test-Path $reportsDir) {
-    [System.IO.File]::WriteAllText((Join-Path $reportsDir "summaryTemp.txt"), $summaryContent, [System.Text.Encoding]::ASCII)
+# Enterprise Automation - Test Reports Aggregator Wrapper
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$pythonCmd = Get-Command python -ErrorAction SilentlyContinue
+if (-not $pythonCmd) { $pythonCmd = Get-Command py -ErrorAction SilentlyContinue }
+if (-not $pythonCmd) { $pythonCmd = Get-Command python3 -ErrorAction SilentlyContinue }
+
+if ($pythonCmd) {
+    & $pythonCmd.Source "$scriptDir\generate_test_reports.py" $args
+    exit $LASTEXITCODE
+} else {
+    Write-Error "Python 3 is required to run generate_test_reports.py."
+    exit 1
 }
-
-# 3. Synchronize report files into TestReports/<Project>_<timestamp>/ if Katalon saved to Reports/
-if ($latestReport) {
-    $reportParentDir = $latestReport.Directory.FullName
-    $nowStr = Get-Date -Format "yyyyMMddHHmmss"
-    if ($ProjectName -match "_\d{10,14}$") {
-        $targetProjDir = Join-Path $testReportsDir $ProjectName
-    } else {
-        $targetProjDir = Join-Path $testReportsDir "${ProjectName}_$nowStr"
-    }
-    $targetSubDir = Join-Path $targetProjDir (Split-Path $reportParentDir -Leaf)
-
-    if (-not (Test-Path $targetSubDir)) {
-        New-Item -ItemType Directory -Path $targetSubDir -Force | Out-Null
-    }
-
-    Copy-Item -Path "$reportParentDir\*" -Destination $targetSubDir -Recurse -Force
-    Write-Host "[+] Synced artifacts to: $targetSubDir" -ForegroundColor Green
-
-    # Ensure results.html exists in targetProjDir
-    $htmlFiles = Get-ChildItem -Path $targetSubDir -Filter "*.html"
-    if ($htmlFiles.Count -gt 0) {
-        Copy-Item -Path $htmlFiles[0].FullName -Destination (Join-Path $targetProjDir "results.html") -Force
-        Write-Host "[+] Created results.html in: $targetProjDir" -ForegroundColor Green
-    }
-}
-
-Write-Host "=== [Centralize CI/CD] Report Generation Complete ===" -ForegroundColor Cyan

package/tools/generate_test_reports.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+Enterprise Test Report Aggregator & summaryTemp Generator (Cross-Platform)
+-------------------------------------------------------------------------
+Parses JUnit XML and Allure test reports across target directories
+and exports standardized summaryTemp.txt for CI/CD dashboards.
+Replaces PowerShell-only script with a zero-dependency, cross-platform engine.
+"""
+
+import os
+import sys
+import glob
+import argparse
+import xml.etree.ElementTree as ET
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, ".."))
+
+
+def find_latest_junit_report(search_dirs):
+    """Finds the most recent JUnit XML file across the given search directories."""
+    candidates = []
+    for d in search_dirs:
+        if os.path.exists(d):
+            for pattern in ["**/*junit*.xml", "**/*test*.xml", "**/TEST-*.xml", "**/*.xml"]:
+                for p in glob.glob(os.path.join(d, pattern), recursive=True):
+                    try:
+                        mtime = os.path.getmtime(p)
+                        candidates.append((mtime, p))
+                    except OSError:
+                        pass
+    if not candidates:
+        return None
+    candidates.sort(key=lambda x: x[0], reverse=True)
+    return candidates[0][1]
+
+
+def parse_junit_xml(xml_path):
+    """Parses a JUnit XML file and returns (passed, failures, errors, skipped)."""
+    try:
+        tree = ET.parse(xml_path)
+        root = tree.getroot()
+    except Exception as e:
+        print(f"[WARN] Failed to parse XML file {xml_path}: {e}")
+        return 0, 0, 0, 0
+
+    total_tests = 0
+    failures = 0
+    errors = 0
+    skipped = 0
+
+    if root.tag == "testsuites":
+        total_tests = int(root.attrib.get("tests", 0))
+        failures = int(root.attrib.get("failures", 0))
+        errors = int(root.attrib.get("errors", 0))
+        skipped = int(root.attrib.get("skipped", 0))
+        passed_attr = root.attrib.get("passed")
+        if passed_attr is not None:
+            return int(passed_attr), failures, errors, skipped
+    elif root.tag == "testsuite":
+        total_tests = int(root.attrib.get("tests", 0))
+        failures = int(root.attrib.get("failures", 0))
+        errors = int(root.attrib.get("errors", 0))
+        skipped = int(root.attrib.get("skipped", 0))
+    else:
+        # Count testcase elements
+        for tc in root.iter("testcase"):
+            total_tests += 1
+            if tc.find("failure") is not None:
+                failures += 1
+            elif tc.find("error") is not None:
+                errors += 1
+            elif tc.find("skipped") is not None:
+                skipped += 1
+
+    passed = max(0, total_tests - (failures + errors + skipped))
+    return passed, failures, errors, skipped
+
+
+def generate_reports(target_dir=None, project_name="Enterprise-Automation"):
+    """Aggregates reports and outputs summaryTemp.txt."""
+    root_dir = target_dir or PROJECT_ROOT
+    reports_dir = os.path.join(root_dir, "Reports")
+    test_reports_dir = os.path.join(root_dir, "TestReports")
+
+    os.makedirs(test_reports_dir, exist_ok=True)
+    summary_file = os.path.join(test_reports_dir, "summaryTemp.txt")
+
+    # Check if summary already exists
+    for check_dir in [reports_dir, test_reports_dir]:
+        existing = os.path.join(check_dir, "summaryTemp.txt")
+        if os.path.exists(existing):
+            try:
+                with open(existing, "r", encoding="utf-8") as f:
+                    content = f.read().strip()
+                if "Passed" in content:
+                    print(f"[+] Found existing summary file: {existing}")
+                    return 0
+            except OSError:
+                pass
+
+    latest_xml = find_latest_junit_report([reports_dir, test_reports_dir, root_dir])
+    if latest_xml:
+        print(f"[+] Parsing latest JUnit XML report: {latest_xml}")
+        passed, failures, errors, skipped = parse_junit_xml(latest_xml)
+    else:
+        print("[!] No JUnit XML report found on disk. Initializing zero-baseline.")
+        passed, failures, errors, skipped = 0, 0, 0, 0
+
+    summary_text = (
+        f"Summary: {passed} Passed - {failures} Failures - {errors} Errors - {skipped} Skipped\n"
+        f"Project: {project_name}\n"
+    )
+
+    with open(summary_file, "w", encoding="utf-8") as f:
+        f.write(summary_text)
+
+    print(f"[+] Summary report saved to: {summary_file}")
+    print(f"    {summary_text.strip()}")
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Aggregate test reports and generate summaryTemp.txt")
+    parser.add_argument("target", nargs="?", default=None, help="Target project root directory")
+    parser.add_argument("--project-name", default="Enterprise-Automation", help="Project label for summary")
+    args = parser.parse_args()
+
+    sys.exit(generate_reports(args.target, project_name=args.project_name))
+
+
+if __name__ == "__main__":
+    main()

package/tools/generate_test_reports.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# Enterprise Test Reports Aggregator Wrapper
+set -e
+python3 "$(dirname "$0")/generate_test_reports.py" "$@"