synapse-hub 2.2.3 → 2.4.0

package/tools/generate_allure_report.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+Enterprise Allure HTML Report Generator (Cross-Platform)
+---------------------------------------------------------
+Dispatches Allure report generation and local web serving across Windows, macOS, and Linux.
+Replaces legacy PowerShell-only scripts with a zero-dependency, cross-platform engine.
+"""
+
+import os
+import sys
+import shutil
+import subprocess
+import argparse
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, ".."))
+
+
+def generate_allure_report(results_dir=None, report_dir=None, clean=True, open_browser=False):
+    """Generates an Allure HTML report from raw result files."""
+    results_path = results_dir or os.path.join(PROJECT_ROOT, "allure-results")
+    report_path = report_dir or os.path.join(PROJECT_ROOT, "allure-report")
+
+    if not os.path.exists(results_path):
+        print(f"[!] Results directory not found: {results_path}")
+        print("[!] Please execute your test suite first to generate raw test result files.")
+        return 0
+
+    allure_cmd = shutil.which("allure")
+    if not allure_cmd:
+        print("[!] Allure CLI executable was not found on PATH.")
+        print("[*] Quick installation instructions:")
+        print("    npm install -g allure-commandline")
+        print("    brew install allure  (macOS)")
+        print("    scoop install allure  (Windows)")
+        return 1
+
+    cmd = [allure_cmd, "generate", results_path, "-o", report_path]
+    if clean:
+        cmd.append("--clean")
+
+    print(f"[+] Generating Allure HTML report from '{results_path}' to '{report_path}'...")
+    try:
+        ret = subprocess.run(cmd, check=True)
+        print(f"[+] Report generated successfully at: {report_path}")
+    except subprocess.CalledProcessError as e:
+        print(f"[ERROR] Allure report generation failed with exit code {e.returncode}")
+        return e.returncode
+
+    if open_browser:
+        print("[+] Launching Allure report server...")
+        try:
+            subprocess.run([allure_cmd, "open", report_path])
+        except KeyboardInterrupt:
+            print("\n[+] Allure server closed.")
+
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate and serve Allure HTML test reports")
+    parser.add_argument("--results-dir", default=None, help="Directory containing raw allure-results")
+    parser.add_argument("--report-dir", default=None, help="Output directory for generated HTML report")
+    parser.add_argument("--no-clean", action="store_true", help="Do not clean output report directory before generation")
+    parser.add_argument("--open", action="store_true", help="Automatically open report in browser via local server")
+    args = parser.parse_args()
+
+    sys.exit(generate_allure_report(
+        results_dir=args.results_dir,
+        report_dir=args.report_dir,
+        clean=not args.no_clean,
+        open_browser=args.open
+    ))
+
+
+if __name__ == "__main__":
+    main()

package/tools/generate_allure_report.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# Enterprise Allure Report Generator Wrapper
+set -e
+python3 "$(dirname "$0")/generate_allure_report.py" "$@"

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,
@@ -122,6 +160,16 @@ def build_jmx_xml(
         f'            <stringProp name="Argument.value">{sla_p95}</stringProp>',
         '            <stringProp name="Argument.metadata">=</stringProp>',
         '          </elementProp>',
+        '          <elementProp name="MAX_LATENCY" elementType="Argument">',
+        '            <stringProp name="Argument.name">MAX_LATENCY</stringProp>',
+        f'            <stringProp name="Argument.value">${{__P(max_latency, {max(3000, sla_p95 * 2)})}}</stringProp>',
+        '            <stringProp name="Argument.metadata">=</stringProp>',
+        '          </elementProp>',
+        '          <elementProp name="LAST_CREATED_ID" elementType="Argument">',
+        '            <stringProp name="Argument.name">LAST_CREATED_ID</stringProp>',
+        '            <stringProp name="Argument.value">1</stringProp>',
+        '            <stringProp name="Argument.metadata">=</stringProp>',
+        '          </elementProp>',
         '          <elementProp name="BEARER_TOKEN" elementType="Argument">',
         '            <stringProp name="Argument.name">BEARER_TOKEN</stringProp>',
         '            <stringProp name="Argument.value"></stringProp>',
@@ -341,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:
@@ -469,9 +540,9 @@ def build_jmx_xml(
             f'{indent}    <intProp name="Assertion.test_type">40</intProp>',
             f'{indent}  </ResponseAssertion>',
             f'{indent}  <hashTree/>',
-            f'{indent}  <!-- SLA Latency Assertion -->',
-            f'{indent}  <DurationAssertion guiclass="DurationAssertionGui" testclass="DurationAssertion" testname="Assert SLA Latency (&lt; ${{SLA_P95}}ms)" enabled="true">',
-            f'{indent}    <stringProp name="DurationAssertion.duration">${{SLA_P95}}</stringProp>',
+            f'{indent}  <!-- SLA Ceiling Assertion (Percentile P95 is validated post-run by jtl_analyzer.py) -->',
+            f'{indent}  <DurationAssertion guiclass="DurationAssertionGui" testclass="DurationAssertion" testname="Assert Max Latency Ceiling (&lt; ${{MAX_LATENCY}}ms)" enabled="true">',
+            f'{indent}    <stringProp name="DurationAssertion.duration">${{MAX_LATENCY}}</stringProp>',
             f'{indent}  </DurationAssertion>',
             f'{indent}  <hashTree/>'
         ])
@@ -492,7 +563,7 @@ def build_jmx_xml(
                 f'{indent}  <!-- Deep Correlation: Random Array Item Selection (Match No: 0) -->',
                 f'{indent}  <JSONPostProcessor guiclass="JSONPostProcessorGui" testclass="JSONPostProcessor" testname="JSON Extractor - Random Item Selector" enabled="true">',
                 f'{indent}    <stringProp name="JSONPostProcessor.referenceNames">RANDOM_ITEM_ID</stringProp>',
-                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$..items[?(@.stock &gt; 0)].id, $..id, $..code</stringProp>',
+                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$..id</stringProp>',
                 f'{indent}    <stringProp name="JSONPostProcessor.match_numbers">0</stringProp>',
                 f'{indent}    <stringProp name="JSONPostProcessor.defaultValues">${{RANDOM_ITEM_ID}}</stringProp>',
                 f'{indent}  </JSONPostProcessor>',
@@ -505,7 +576,7 @@ def build_jmx_xml(
                 f'{indent}  <!-- Auto-Extract Dynamic Bearer Token -->',
                 f'{indent}  <JSONPostProcessor guiclass="JSONPostProcessorGui" testclass="JSONPostProcessor" testname="JSON Extractor - Bearer Token" enabled="true">',
                 f'{indent}    <stringProp name="JSONPostProcessor.referenceNames">BEARER_TOKEN</stringProp>',
-                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$.token, $.access_token, $.data.token, $.data.access_token</stringProp>',
+                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$..[\'token\',\'access_token\']</stringProp>',
                 f'{indent}    <stringProp name="JSONPostProcessor.match_numbers">1</stringProp>',
                 f'{indent}    <stringProp name="JSONPostProcessor.defaultValues">${{BEARER_TOKEN}}</stringProp>',
                 f'{indent}  </JSONPostProcessor>',
@@ -516,9 +587,9 @@ def build_jmx_xml(
                 f'{indent}  <!-- Auto-Extract Created Entity ID -->',
                 f'{indent}  <JSONPostProcessor guiclass="JSONPostProcessorGui" testclass="JSONPostProcessor" testname="JSON Extractor - Entity ID" enabled="true">',
                 f'{indent}    <stringProp name="JSONPostProcessor.referenceNames">LAST_CREATED_ID</stringProp>',
-                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$.id, $.code, $.data.id, $.data.code</stringProp>',
+                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$..[\'id\',\'code\']</stringProp>',
                 f'{indent}    <stringProp name="JSONPostProcessor.match_numbers">1</stringProp>',
-                f'{indent}    <stringProp name="JSONPostProcessor.defaultValues"></stringProp>',
+                f'{indent}    <stringProp name="JSONPostProcessor.defaultValues">${{LAST_CREATED_ID}}</stringProp>',
                 f'{indent}  </JSONPostProcessor>',
                 f'{indent}  <hashTree/>'
             ])
@@ -667,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>'
@@ -716,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", {})
@@ -752,7 +938,10 @@ def parse_openapi_for_jmeter(spec_data: Dict[str, Any]) -> tuple:
 
             def replace_path_param(match):
                 pname = match.group(1)
-                if pname.lower() in ("id", "categoryid", "entityid", "userid"):
+                plow = pname.lower()
+                if plow in ("itemid", "productid", "item_id", "product_id"):
+                    return "${RANDOM_ITEM_ID}"
+                if plow in ("id", "categoryid", "entityid", "userid", "orderid", "order_id"):
                     return "${LAST_CREATED_ID}"
                 return f"${{{pname}}}"
 
@@ -794,6 +983,25 @@ def parse_openapi_for_jmeter(spec_data: Dict[str, Any]) -> tuple:
                 "expected_status": expected_status
             })
 
+    def sampler_sort_key(s: Dict[str, Any]) -> int:
+        p = s.get("path", "").lower()
+        m = s.get("method", "GET")
+        if "auth" in p or "login" in p or "token" in p:
+            return 1
+        if m == "POST" and "{" not in s.get("path", "") and "${" not in s.get("path", ""):
+            return 2
+        if m == "GET" and "{" not in s.get("path", "") and "${" not in s.get("path", ""):
+            return 3
+        if m == "GET":
+            return 4
+        if m in ("PUT", "PATCH"):
+            return 5
+        if m == "DELETE":
+            return 6
+        return 7
+
+    samplers.sort(key=sampler_sort_key)
+
     return plan_name, base_host, protocol, port, samplers
 
 
@@ -897,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
@@ -993,8 +1202,8 @@ def main():
         plan_name, base_host, protocol, port, samplers = parse_openapi_for_jmeter(spec_data)
     else:
         # Fallback to built-in sample spec
-        from export_postman_collection import get_sample_spec
-        spec_data = get_sample_spec()
+        from export_postman_collection import get_domain_spec
+        spec_data = get_domain_spec("ecommerce")
         plan_name, base_host, protocol, port, samplers = parse_openapi_for_jmeter(spec_data)
 
     # Base URL override if provided
@@ -1007,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,