robotmk-bridge-testdatagenerator 0.3.0__tar.gz

robotmk_bridge_testdatagenerator-0.3.0/.gitignore

@@ -0,0 +1,16 @@
+dist/
+build/
+*.egg-info/
+__pycache__/
+*.py[cod]
+.venv/
+.env
+*.whl
+*.tar.gz
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.claude
+_bmad-output
+docs
+_bmad

robotmk_bridge_testdatagenerator-0.3.0/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+## [0.3.0](https://github.com/elabit/robotmk-bridge-testdatagenerator/compare/v0.2.0...v0.3.0) (2026-06-24)
+
+
+### Features
+
+* init commit, pypi init ([1d278e6](https://github.com/elabit/robotmk-bridge-testdatagenerator/commit/1d278e64b068e6b17a922cb3fe85ad330971e41c))
+
+
+### Bug Fixes
+
+* deleted publish workflow ([a046128](https://github.com/elabit/robotmk-bridge-testdatagenerator/commit/a046128ed5e7f9fcc2c271b89676f35ee37ca45e))
+
+## [0.2.0](https://github.com/elabit/robotmk-bridge-testdatagenerator/compare/v0.1.0...v0.2.0) (2026-06-24)
+
+
+### Features
+
+* init commit, pypi init ([1d278e6](https://github.com/elabit/robotmk-bridge-testdatagenerator/commit/1d278e64b068e6b17a922cb3fe85ad330971e41c))
+
+## Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+Changelog entries are managed automatically by [release-please](https://github.com/googleapis/release-please).
+
+<!-- Release notes are appended above this line by release-please -->

robotmk_bridge_testdatagenerator-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Simon Meggle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

robotmk_bridge_testdatagenerator-0.3.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: robotmk-bridge-testdatagenerator
+Version: 0.3.0
+Summary: Generates synthetic test result files (JUnit, ZAP, Gatling) for robotmk-bridge-plugin testing
+Project-URL: Homepage, https://github.com/simonmeggle/robotmk-bridge-testdatagenerator
+Project-URL: Issues, https://github.com/simonmeggle/robotmk-bridge-testdatagenerator/issues
+Author-email: Simon Meggle <simon.meggle@checkmk.com>
+License: MIT
+License-File: LICENSE
+Keywords: checkmk,gatling,junit,robotmk,test-data,testing,zap
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Requires-Dist: pyyaml>=5.4
+Description-Content-Type: text/markdown
+
+# robotmk-bridge-testdatagenerator
+
+Generates synthetic test result files for [robotmk-bridge-plugin](https://github.com/simonmeggle/robotmk-bridge-plugin) testing. Produces realistic, randomized output in the formats consumed by the bridge plugin's handlers.
+
+## Supported Formats
+
+| Handler | Format | Extension |
+|---|---|---|
+| `junit` | JUnit XML | `.xml` |
+| `zaproxy` | OWASP ZAP XML v2.7.0 | `.xml` |
+| `gatling` | Gatling simulation.log v2.0 | `.log` |
+
+## Installation
+
+```bash
+pip install robotmk-bridge-testdatagenerator
+```
+
+## CLI Usage
+
+```bash
+# Generate all handlers (output: tests/e2e/data/)
+rmkb-testgen
+
+# Specify output directory and status
+rmkb-testgen --output-dir /tmp/test-data --status failed
+
+# Generate specific handlers only
+rmkb-testgen --handlers junit gatling
+
+# Continuous mode (Ctrl+C to stop)
+rmkb-testgen --continuous --interval 5
+
+# List available handlers
+rmkb-testgen --list
+```
+
+### Options
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--output-dir` | `-o` | `tests/e2e/data` | Output directory |
+| `--status` | `-s` | `passed` | `passed` / `failed` / `mixed` |
+| `--handlers` | `-H` | all | Specific handlers to generate |
+| `--pattern` | `-p` | `{handler}.{ext}` | Filename pattern |
+| `--continuous` | `-c` | off | Regenerate on interval |
+| `--interval` | `-i` | `5.0` | Seconds between generations |
+| `--list` | `-l` | — | List handlers and exit |
+| `--verbose` | `-v` | off | Verbose output |
+
+## Library Usage
+
+```python
+from robotmk_bridge_testdatagenerator import (
+    generate_all_handler_files,
+    generate_handler_file,
+    get_supported_handlers,
+)
+from pathlib import Path
+
+# Generate all handlers
+files = generate_all_handler_files(Path("/tmp/test-data"), test_status="mixed")
+
+# Generate a single handler
+generate_handler_file("junit", Path("/tmp/result.xml"), test_status="failed")
+
+# List handlers
+handlers = get_supported_handlers()  # ['junit', 'gatling', 'zaproxy']
+```
+
+## Custom handlers.yaml
+
+By default the bundled `handlers.yaml` is used. Override via environment variable:
+
+```bash
+ROBOTMK_HANDLERS_YAML=/path/to/your/handlers.yaml rmkb-testgen
+```
+
+## Test Status Semantics
+
+| Status | JUnit | ZAP | Gatling |
+|---|---|---|---|
+| `passed` | All pass | Low-risk alerts only | All requests OK |
+| `failed` | All fail | High-risk alerts | All requests KO |
+| `mixed` | Every 3rd fails | Low + medium risk | Every 4th KO |
+
+## License
+
+MIT

robotmk_bridge_testdatagenerator-0.3.0/README.md

@@ -0,0 +1,89 @@
+# robotmk-bridge-testdatagenerator
+
+Generates synthetic test result files for [robotmk-bridge-plugin](https://github.com/simonmeggle/robotmk-bridge-plugin) testing. Produces realistic, randomized output in the formats consumed by the bridge plugin's handlers.
+
+## Supported Formats
+
+| Handler | Format | Extension |
+|---|---|---|
+| `junit` | JUnit XML | `.xml` |
+| `zaproxy` | OWASP ZAP XML v2.7.0 | `.xml` |
+| `gatling` | Gatling simulation.log v2.0 | `.log` |
+
+## Installation
+
+```bash
+pip install robotmk-bridge-testdatagenerator
+```
+
+## CLI Usage
+
+```bash
+# Generate all handlers (output: tests/e2e/data/)
+rmkb-testgen
+
+# Specify output directory and status
+rmkb-testgen --output-dir /tmp/test-data --status failed
+
+# Generate specific handlers only
+rmkb-testgen --handlers junit gatling
+
+# Continuous mode (Ctrl+C to stop)
+rmkb-testgen --continuous --interval 5
+
+# List available handlers
+rmkb-testgen --list
+```
+
+### Options
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--output-dir` | `-o` | `tests/e2e/data` | Output directory |
+| `--status` | `-s` | `passed` | `passed` / `failed` / `mixed` |
+| `--handlers` | `-H` | all | Specific handlers to generate |
+| `--pattern` | `-p` | `{handler}.{ext}` | Filename pattern |
+| `--continuous` | `-c` | off | Regenerate on interval |
+| `--interval` | `-i` | `5.0` | Seconds between generations |
+| `--list` | `-l` | — | List handlers and exit |
+| `--verbose` | `-v` | off | Verbose output |
+
+## Library Usage
+
+```python
+from robotmk_bridge_testdatagenerator import (
+    generate_all_handler_files,
+    generate_handler_file,
+    get_supported_handlers,
+)
+from pathlib import Path
+
+# Generate all handlers
+files = generate_all_handler_files(Path("/tmp/test-data"), test_status="mixed")
+
+# Generate a single handler
+generate_handler_file("junit", Path("/tmp/result.xml"), test_status="failed")
+
+# List handlers
+handlers = get_supported_handlers()  # ['junit', 'gatling', 'zaproxy']
+```
+
+## Custom handlers.yaml
+
+By default the bundled `handlers.yaml` is used. Override via environment variable:
+
+```bash
+ROBOTMK_HANDLERS_YAML=/path/to/your/handlers.yaml rmkb-testgen
+```
+
+## Test Status Semantics
+
+| Status | JUnit | ZAP | Gatling |
+|---|---|---|---|
+| `passed` | All pass | Low-risk alerts only | All requests OK |
+| `failed` | All fail | High-risk alerts | All requests KO |
+| `mixed` | Every 3rd fails | Low + medium risk | Every 4th KO |
+
+## License
+
+MIT

robotmk_bridge_testdatagenerator-0.3.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "robotmk-bridge-testdatagenerator"
+version = "0.3.0"
+description = "Generates synthetic test result files (JUnit, ZAP, Gatling) for robotmk-bridge-plugin testing"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+authors = [{ name = "Simon Meggle", email = "simon.meggle@checkmk.com" }]
+keywords = ["robotmk", "checkmk", "testing", "junit", "gatling", "zap", "test-data"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = ["pyyaml>=5.4"]
+
+[project.scripts]
+rmkb-testgen = "robotmk_bridge_testdatagenerator.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/simonmeggle/robotmk-bridge-testdatagenerator"
+Issues = "https://github.com/simonmeggle/robotmk-bridge-testdatagenerator/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/robotmk_bridge_testdatagenerator"]
+
+[tool.hatch.build.targets.wheel.shared-data]
+# handlers.yaml is included as package data, not shared-data
+# (it's inside the package directory, hatchling includes it automatically)
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+]

robotmk_bridge_testdatagenerator-0.3.0/src/robotmk_bridge_testdatagenerator/__init__.py

@@ -0,0 +1,17 @@
+"""Test data generator for robotmk-bridge-plugin.
+
+Generates realistic test result files for different handler types
+(JUnit, ZAP, Gatling). Used by both e2e tests and unit test fixtures.
+"""
+
+from .generator import (
+    generate_all_handler_files,
+    generate_handler_file,
+    get_supported_handlers,
+)
+
+__all__ = [
+    "generate_all_handler_files",
+    "generate_handler_file",
+    "get_supported_handlers",
+]

robotmk_bridge_testdatagenerator-0.3.0/src/robotmk_bridge_testdatagenerator/__main__.py

@@ -0,0 +1,215 @@
+"""CLI entry point for the test data generator.
+
+Usage:
+    rmkb-testgen [options]
+    python -m robotmk_bridge_testdatagenerator [options]
+
+Examples:
+    # Generate all handler test files in default location
+    rmkb-testgen
+
+    # Generate in a specific directory
+    rmkb-testgen --output-dir /tmp/test-data
+
+    # Generate with failed test status
+    rmkb-testgen --status failed
+
+    # Generate only specific handlers
+    rmkb-testgen --handlers junit gatling
+
+    # Continuous mode: regenerate every 5 seconds
+    rmkb-testgen --continuous --interval 5
+
+    # Use a custom handlers.yaml
+    ROBOTMK_HANDLERS_YAML=/path/to/handlers.yaml rmkb-testgen
+"""
+
+import argparse
+import signal
+import sys
+import time
+from pathlib import Path
+
+from .generator import (
+    generate_all_handler_files,
+    generate_handler_file,
+    get_supported_handlers,
+)
+
+_shutdown_requested = False
+
+
+def signal_handler(signum, frame):
+    global _shutdown_requested
+    _shutdown_requested = True
+    print("\n\nShutdown requested. Stopping after current generation...")
+
+
+def generate_files(args):
+    """Generate test data files based on arguments."""
+    if args.handlers:
+        generated_files = {}
+        for handler in args.handlers:
+            from .generator import load_handlers_registry
+            handlers_def = load_handlers_registry()
+            handler_def = next(
+                (h for h in handlers_def if h["name"] == handler), None
+            )
+            if not handler_def:
+                print(f"Error: Handler '{handler}' not found", file=sys.stderr)
+                sys.exit(1)
+
+            result_ext = handler_def.get("result_ext", "txt")
+            filename = args.pattern.format(handler=handler, ext=result_ext)
+            output_path = args.output_dir / filename
+            generate_handler_file(
+                handler_name=handler,
+                output_path=output_path,
+                test_status=args.status,
+            )
+            generated_files[handler] = output_path
+    else:
+        generated_files = generate_all_handler_files(
+            output_dir=args.output_dir,
+            test_status=args.status,
+            filename_pattern=args.pattern,
+        )
+    return generated_files
+
+
+def main():
+    """CLI entry point for test data generation."""
+    parser = argparse.ArgumentParser(
+        description="Generate test result files for Robotmk Bridge handlers",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  Generate all handlers:
+    rmkb-testgen
+
+  Specific output directory:
+    rmkb-testgen --output-dir /tmp/test-data
+
+  Failed status:
+    rmkb-testgen --status failed
+
+  Specific handlers:
+    rmkb-testgen --handlers junit gatling
+
+  Continuous mode (Ctrl+C to stop):
+    rmkb-testgen --continuous --interval 5
+
+  Custom handlers.yaml:
+    ROBOTMK_HANDLERS_YAML=/path/to/handlers.yaml rmkb-testgen
+        """,
+    )
+
+    parser.add_argument(
+        "-o", "--output-dir",
+        type=Path,
+        default=Path("tests/e2e/data"),
+        help="Output directory for generated test files (default: tests/e2e/data)",
+    )
+    parser.add_argument(
+        "-s", "--status",
+        choices=["passed", "failed", "mixed"],
+        default="passed",
+        help="Test status for generated files (default: passed)",
+    )
+    parser.add_argument(
+        "-H", "--handlers",
+        nargs="+",
+        choices=get_supported_handlers(),
+        help="Generate only specific handlers (default: all)",
+    )
+    parser.add_argument(
+        "-p", "--pattern",
+        default="{handler}.{ext}",
+        help="Filename pattern (default: {handler}.{ext})",
+    )
+    parser.add_argument(
+        "-c", "--continuous",
+        action="store_true",
+        help="Continuous mode: regenerate files at regular intervals",
+    )
+    parser.add_argument(
+        "-i", "--interval",
+        type=float,
+        default=5.0,
+        help="Interval in seconds between generations in continuous mode (default: 5)",
+    )
+    parser.add_argument(
+        "-l", "--list",
+        action="store_true",
+        help="List supported handlers and exit",
+    )
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Enable verbose output",
+    )
+
+    args = parser.parse_args()
+
+    if args.list:
+        print("Supported handlers:")
+        for handler in get_supported_handlers():
+            print(f"  - {handler}")
+        return 0
+
+    if args.interval <= 0:
+        print("Error: Interval must be greater than 0", file=sys.stderr)
+        return 1
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    if args.verbose:
+        print(f"Output directory: {args.output_dir.absolute()}")
+        print(f"Test status: {args.status}")
+        print(f"Filename pattern: {args.pattern}")
+        if args.continuous:
+            print(f"Continuous mode: regenerating every {args.interval}s")
+            print("Press Ctrl+C to stop\n")
+
+    try:
+        if args.continuous:
+            generation_count = 0
+            while not _shutdown_requested:
+                generation_count += 1
+                timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+                if args.verbose:
+                    print(f"[{timestamp}] Generation #{generation_count}")
+                generated_files = generate_files(args)
+                if generation_count == 1 or args.verbose:
+                    print(f"Generated {len(generated_files)} test file(s):")
+                    for handler, path in generated_files.items():
+                        size = path.stat().st_size
+                        print(f"  ✓ {handler:12s} → {path.name:20s} ({size:,} bytes)")
+                else:
+                    print(f"[{timestamp}] Generation #{generation_count}: "
+                          f"{len(generated_files)} files updated")
+                if not _shutdown_requested:
+                    if args.verbose:
+                        print(f"Waiting {args.interval}s until next generation...\n")
+                    time.sleep(args.interval)
+            print(f"\nStopped after {generation_count} generation(s)")
+        else:
+            generated_files = generate_files(args)
+            print(f"Generated {len(generated_files)} test file(s):")
+            for handler, path in generated_files.items():
+                size = path.stat().st_size
+                print(f"  ✓ {handler:12s} → {path.name:20s} ({size:,} bytes)")
+        return 0
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        if args.verbose:
+            import traceback
+            traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

robotmk_bridge_testdatagenerator-0.3.0/src/robotmk_bridge_testdatagenerator/generator.py

@@ -0,0 +1,167 @@
+"""Core test data generator module.
+
+Reads the bundled handlers.yaml (or ROBOTMK_HANDLERS_YAML env override) and
+provides a unified API for generating test result files for different handler types.
+"""
+
+import os
+from importlib import resources
+from pathlib import Path
+from typing import Dict, List
+
+import yaml
+
+
+def _open_handlers_yaml():
+    """Return an open file-like object for handlers.yaml.
+
+    Checks ROBOTMK_HANDLERS_YAML env var first; falls back to the file
+    bundled inside the package via importlib.resources.
+    """
+    env_override = os.environ.get("ROBOTMK_HANDLERS_YAML")
+    if env_override:
+        return open(env_override, "r", encoding="utf-8")
+    ref = resources.files("robotmk_bridge_testdatagenerator").joinpath("handlers.yaml")
+    return ref.open("r", encoding="utf-8")
+
+
+def load_handlers_registry() -> List[Dict]:
+    """Load handler definitions from handlers.yaml.
+
+    Returns:
+        List of handler definitions, each with 'name', 'title', 'class_import',
+        'result_ext', and optional 'handler_params'.
+    """
+    with _open_handlers_yaml() as f:
+        data = yaml.safe_load(f)
+
+    if not data or "handlers" not in data:
+        raise ValueError("handlers.yaml must contain a 'handlers' key")
+
+    return data["handlers"]
+
+
+def get_supported_handlers() -> List[str]:
+    """Return list of handler names from handlers.yaml.
+
+    Returns:
+        List of handler names (e.g., ['junit', 'gatling', 'zaproxy'])
+    """
+    return [h["name"] for h in load_handlers_registry()]
+
+
+def generate_handler_file(
+    handler_name: str,
+    output_path: Path,
+    test_status: str = "passed",
+    **kwargs
+) -> Path:
+    """Generate a test result file for the specified handler.
+
+    Args:
+        handler_name: Name of handler (e.g., 'junit', 'zaproxy', 'gatling')
+        output_path: Path where the result file should be written
+        test_status: Test outcome - 'passed', 'failed', or 'mixed' (default: 'passed')
+        **kwargs: Handler-specific parameters (e.g., num_tests, duration_ms)
+
+    Returns:
+        Path to the generated file
+
+    Raises:
+        ValueError: If handler_name is not supported
+        RuntimeError: If handler generator fails
+    """
+    handlers = load_handlers_registry()
+    handler_def = next((h for h in handlers if h["name"] == handler_name), None)
+
+    if not handler_def:
+        supported = [h["name"] for h in handlers]
+        raise ValueError(
+            f"Handler '{handler_name}' not found in handlers.yaml. "
+            f"Supported handlers: {', '.join(supported)}"
+        )
+
+    handler_to_module = {
+        "zaproxy": "zap",
+        "junit": "junit",
+        "gatling": "gatling",
+    }
+
+    module_name = handler_to_module.get(handler_name, handler_name)
+
+    try:
+        from . import handlers as handler_module
+        generator_name = f"{module_name}_generator"
+        generator = getattr(handler_module, generator_name)
+    except (ImportError, AttributeError) as e:
+        raise RuntimeError(
+            f"Could not import generator for '{handler_name}'. "
+            f"Expected module: robotmk_bridge_testdatagenerator.handlers.{generator_name}"
+        ) from e
+
+    try:
+        generator.generate(
+            output_path=output_path,
+            test_status=test_status,
+            handler_def=handler_def,
+            **kwargs
+        )
+    except Exception as e:
+        raise RuntimeError(
+            f"Failed to generate test data for handler '{handler_name}': {e}"
+        ) from e
+
+    try:
+        if output_path.exists():
+            output_path.chmod(0o644)
+    except Exception:
+        pass
+
+    return output_path
+
+
+def generate_all_handler_files(
+    output_dir: Path,
+    test_status: str = "passed",
+    filename_pattern: str = "{handler}.{ext}"
+) -> Dict[str, Path]:
+    """Generate test result files for all supported handlers.
+
+    Args:
+        output_dir: Directory where files should be written
+        test_status: Test outcome - 'passed', 'failed', or 'mixed'
+        filename_pattern: Pattern for output filenames (variables: {handler}, {ext})
+
+    Returns:
+        Dict mapping handler name to generated file path
+
+    Example:
+        >>> files = generate_all_handler_files(Path("tests/e2e/data"))
+        >>> files
+        {'junit': Path('tests/e2e/data/junit.xml'),
+         'gatling': Path('tests/e2e/data/gatling.log'),
+         'zaproxy': Path('tests/e2e/data/zaproxy.xml')}
+    """
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        output_dir.chmod(0o755)
+    except Exception:
+        pass
+
+    handlers = load_handlers_registry()
+    generated_files = {}
+
+    for handler_def in handlers:
+        handler_name = handler_def["name"]
+        result_ext = handler_def.get("result_ext", "txt")
+        filename = filename_pattern.format(handler=handler_name, ext=result_ext)
+        output_path = output_dir / filename
+        generate_handler_file(
+            handler_name=handler_name,
+            output_path=output_path,
+            test_status=test_status
+        )
+        generated_files[handler_name] = output_path
+
+    return generated_files

robotmk_bridge_testdatagenerator-0.3.0/src/robotmk_bridge_testdatagenerator/handlers/__init__.py

@@ -0,0 +1,11 @@
+"""Handler-specific test data generators."""
+
+from . import junit_generator
+from . import gatling_generator
+from . import zap_generator
+
+__all__ = [
+    "junit_generator",
+    "gatling_generator",
+    "zap_generator",
+]

robotmk_bridge_testdatagenerator-0.3.0/src/robotmk_bridge_testdatagenerator/handlers/gatling_generator.py

@@ -0,0 +1,103 @@
+"""Gatling simulation log test data generator."""
+
+import random
+import time
+from pathlib import Path
+from typing import Dict
+
+
+def generate(
+    output_path: Path,
+    test_status: str = "passed",
+    handler_def: Dict = None,
+    num_requests: int = 10,
+    duration_ms: int = 5000,
+    **kwargs
+) -> None:
+    """Generate a Gatling simulation.log file in v2.0 format.
+    
+    Gatling v2.x logs use tab-separated format with different record types:
+    - RUN: simulation metadata (v2.0 format with FQCN)
+    - REQUEST: individual HTTP request with timing (no simulation name)
+    - USER: user session start/end (group name + numeric ID)
+    
+    Args:
+        output_path: Path where the log file should be written
+        test_status: 'passed', 'failed', or 'mixed'
+        handler_def: Handler definition from handlers.yaml (unused here)
+        num_requests: Number of requests to simulate
+        duration_ms: Total simulation duration in milliseconds
+        **kwargs: Additional parameters (ignored)
+    """
+    base_timestamp = int(time.time() * 1000)  # Current time in milliseconds
+    simulation_fqcn = "computerdatabase.advanced.AdvancedSimulationStep05"
+    run_id = "simulation-001"
+    normalized_name = "advancedsimulationstep05"
+    user_count = max(1, num_requests // 3)
+    
+    # Define user groups (mix of regular users and admins)
+    user_groups = ["Users", "Users", "Admins"]  # More regular users than admins
+    
+    lines = []
+    
+    # RUN record - simulation start (v2.0 format)
+    # Format: RUN\tsimulation_fqcn\trun_id\tnormalized_name\ttimestamp\t \tversion
+    lines.append(f"RUN\t{simulation_fqcn}\t{run_id}\t{normalized_name}\t{base_timestamp}\t \t2.0")
+    
+    # USER records - user sessions start
+    user_sessions = []  # Track (group, id) tuples
+    for user_id in range(user_count):
+        numeric_id = user_id + 1
+        user_group = user_groups[user_id % len(user_groups)]
+        start_time = base_timestamp + (user_id * duration_ms // user_count)
+        user_sessions.append((user_group, numeric_id, start_time))
+        lines.append(f"USER\t{user_group}\t{numeric_id}\tSTART\t{start_time}\t{start_time}")
+    
+    # Generate varied request names
+    request_types = ["Home", "Home Redirect 1", "Search", "Select", "Page 0", "Page 1", 
+                     "Page 2", "Page 3", "Form", "Post", "Post Redirect 1"]
+    
+    # REQUEST records
+    request_interval = duration_ms // num_requests if num_requests > 0 else 100
+    
+    for i in range(num_requests):
+        user_idx = i % user_count
+        user_group, user_id, _ = user_sessions[user_idx]
+        request_name = request_types[i % len(request_types)]
+        
+        request_start = base_timestamp + (i * request_interval)
+        # Add variance: +/- 40% of average duration
+        avg_duration = request_interval // 2
+        request_duration = int(avg_duration * random.uniform(0.6, 1.4))
+        request_end = request_start + request_duration
+        
+        # Determine if this request should fail
+        should_fail = False
+        if test_status == "failed":
+            should_fail = True
+        elif test_status == "mixed" and i % 4 == 0:
+            should_fail = True
+        
+        if should_fail:
+            status = "KO"
+            message = "status.find.is(201), but actually found 200"
+        else:
+            status = "OK"
+            message = " "  # Single space for OK status
+        
+        # REQUEST format (v2.0): REQUEST\tuser_group\tuser_id\t\trequest_name\tstart\tend\tstatus\tmessage
+        # Note: Empty field between user_id and request_name (double tab)
+        lines.append(
+            f"REQUEST\t{user_group}\t{user_id}\t\t{request_name}\t"
+            f"{request_start}\t{request_end}\t{status}\t{message}"
+        )
+    
+    # USER records - user sessions end
+    end_time = base_timestamp + duration_ms
+    for user_group, user_id, start_time in user_sessions:
+        lines.append(f"USER\t{user_group}\t{user_id}\tEND\t{start_time}\t{end_time}")
+    
+    # Write to file
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines))
+        f.write("\n")  # Trailing newline

robotmk_bridge_testdatagenerator-0.3.0/src/robotmk_bridge_testdatagenerator/handlers/junit_generator.py

@@ -0,0 +1,84 @@
+"""JUnit XML test data generator."""
+
+import random
+from datetime import datetime
+from pathlib import Path
+from xml.etree import ElementTree as ET
+from typing import Dict
+
+
+def generate(
+    output_path: Path,
+    test_status: str = "passed",
+    handler_def: Dict = None,
+    num_tests: int = 5,
+    duration_s: float = 2.5,
+    **kwargs
+) -> None:
+    """Generate a JUnit XML result file.
+    
+    Args:
+        output_path: Path where the XML file should be written
+        test_status: 'passed', 'failed', or 'mixed'
+        handler_def: Handler definition from handlers.yaml (unused here)
+        num_tests: Number of test cases to generate
+        duration_s: Total duration in seconds
+        **kwargs: Additional parameters (ignored)
+    """
+    # Create root testsuite element
+    testsuite = ET.Element("testsuite")
+    testsuite.set("name", "RobotmkBridgeTests")
+    testsuite.set("tests", str(num_tests))
+    testsuite.set("time", f"{duration_s:.3f}")
+    testsuite.set("timestamp", datetime.now().strftime("%Y-%m-%dT%H:%M:%S"))
+    
+    failures = 0
+    errors = 0
+    
+    # Generate test cases based on test_status
+    for i in range(num_tests):
+        testcase = ET.SubElement(testsuite, "testcase")
+        testcase.set("classname", f"tests.example.TestSuite{i // 3 + 1}")
+        testcase.set("name", f"test_example_{i + 1}")
+        # Add variance: +/- 30% of average time
+        avg_time = duration_s / num_tests
+        test_time = avg_time * random.uniform(0.7, 1.3)
+        testcase.set("time", f"{test_time:.3f}")
+        
+        # Determine if this test should fail
+        should_fail = False
+        if test_status == "failed":
+            should_fail = True
+        elif test_status == "mixed" and i % 3 == 0:
+            should_fail = True
+        
+        if should_fail:
+            if i % 2 == 0:
+                # Add failure
+                failure = ET.SubElement(testcase, "failure")
+                failure.set("message", f"Assertion failed: Expected value was incorrect")
+                failure.set("type", "AssertionError")
+                failure.text = f"AssertionError: Expected 'success' but got 'failure' at line {i * 10 + 42}"
+                failures += 1
+            else:
+                # Add error
+                error = ET.SubElement(testcase, "error")
+                error.set("message", f"Test runtime error")
+                error.set("type", "RuntimeError")
+                error.text = f"RuntimeError: Connection timeout after 30 seconds"
+                errors += 1
+        else:
+            # Optionally add system-out for passed tests
+            if i % 2 == 0:
+                system_out = ET.SubElement(testcase, "system-out")
+                system_out.text = f"Test {i + 1} executed successfully with no warnings"
+    
+    # Update testsuite attributes
+    testsuite.set("failures", str(failures))
+    testsuite.set("errors", str(errors))
+    testsuite.set("skipped", "0")
+    
+    # Write XML to file
+    tree = ET.ElementTree(testsuite)
+    ET.indent(tree, space="  ")
+    tree.write(output_path, encoding="utf-8", xml_declaration=True)

robotmk_bridge_testdatagenerator-0.3.0/src/robotmk_bridge_testdatagenerator/handlers/zap_generator.py

@@ -0,0 +1,256 @@
+"""OWASP ZAP XML test data generator."""
+
+import random
+from datetime import datetime
+from pathlib import Path
+from typing import Dict
+
+
+def generate(
+    output_path: Path,
+    test_status: str = "passed",
+    handler_def: Dict = None,
+    num_sites: int = 3,
+    **kwargs
+) -> None:
+    """Generate an OWASP ZAP XML report file matching v2.7.0 format.
+    
+    ZAP reports contain alerts with risk levels (0=Info, 1=Low, 2=Medium, 3=High)
+    and confidence levels (0=Low, 1=Medium, 2=High, 3=Confirmed).
+    
+    Args:
+        output_path: Path where the XML file should be written
+        test_status: 'passed' (low risk only), 'failed' (high risk), 'mixed' (varied)
+        handler_def: Handler definition from handlers.yaml (unused here)
+        num_sites: Number of sites to include in report
+        **kwargs: Additional parameters (ignored)
+    """
+    # Generate timestamp in ZAP format: "Tue, 7 Aug 2018 13:17:56"
+    now = datetime.now()
+    timestamp = now.strftime("%a, %-d %b %Y %H:%M:%S")
+    
+    lines = ['<?xml version="1.0"?>']
+    lines.append(f'<OWASPZAPReport version="2.7.0" generated="{timestamp}">')
+    
+    # Define sites to scan with varied number
+    sites = [
+        {"name": "http://localhost:7272", "host": "localhost", "port": "7272", "ssl": "false"},
+        {"name": "http://127.0.0.1:7272", "host": "127.0.0.1", "port": "7272", "ssl": "false"},
+        {"name": "http://192.168.50.56:7272", "host": "192.168.50.56", "port": "7272", "ssl": "false"},
+    ][:num_sites]
+    
+    # Get all available alert types - only use low risk (passing tests)
+    low_alerts = get_low_risk_alerts()
+    
+    # Generate sites with alerts (only low-risk = all passing)
+    for site_idx, site_config in enumerate(sites):
+        lines.append(f'<site name="{site_config["name"]}" host="{site_config["host"]}" '
+                    f'port="{site_config["port"]}" ssl="{site_config["ssl"]}">')
+        lines.append('<alerts>')
+        
+        # Randomize number of alerts per site (vary runtime simulation)
+        num_alerts = random.randint(2, 6)
+        site_alerts = []
+        
+        for _ in range(num_alerts):
+            # Only choose low risk alerts (all tests pass)
+            alert = random.choice(low_alerts).copy()
+            
+            # Vary the number of instances (affects processing time)
+            alert["max_instances"] = random.randint(1, 8)
+            site_alerts.append(alert)
+        
+        for alert in site_alerts:
+            lines.extend(generate_alert_xml(alert, site_config, site_idx))
+        
+        lines.append('</alerts>')
+        lines.append('</site>')
+    
+    lines.append('</OWASPZAPReport>\n')
+    
+    # Write to file
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write("".join(lines))
+
+
+def generate_alert_xml(alert_template: Dict, site_config: Dict, site_idx: int):
+    """Generate XML lines for a single alert item."""
+    lines = ['<alertitem>\n']
+    
+    # Core alert info
+    lines.append(f'  <pluginid>{alert_template["pluginid"]}</pluginid>\n')
+    lines.append(f'  <alert>{alert_template["name"]}</alert>\n')
+    lines.append(f'  <name>{alert_template["name"]}</name>\n')
+    lines.append(f'  <riskcode>{alert_template["riskcode"]}</riskcode>\n')
+    lines.append(f'  <confidence>{alert_template["confidence"]}</confidence>\n')
+    lines.append(f'  <riskdesc>{alert_template["riskdesc"]}</riskdesc>\n')
+    lines.append(f'  <desc>{alert_template["desc"]}</desc>\n')
+    
+    # Instances - vary count to simulate different scan complexities/runtimes
+    lines.append('  <instances>\n')
+    max_instances = alert_template.get("max_instances", 3)
+    num_instances = random.randint(1, max_instances)
+    
+    for i in range(num_instances):
+        lines.append('  <instance>\n')
+        
+        # Generate URI variations
+        base_url = site_config["name"]
+        paths = alert_template.get("paths", ["/", "/index.html", "/api/data"])
+        uri = f'{base_url}{random.choice(paths)}'
+        lines.append(f'  <uri>{uri}</uri>\n')
+        
+        method = random.choice(["GET", "POST"])
+        lines.append(f'  <method>{method}</method>\n')
+        
+        lines.append(f'  <param>{alert_template["param"]}</param>\n')
+        
+        if "evidence" in alert_template:
+            lines.append(f'  <evidence>{alert_template["evidence"]}</evidence>\n')
+        
+        lines.append('  </instance>\n')
+    
+    lines.append('  </instances>\n')
+    lines.append(f'  <count>{num_instances}</count>\n')
+    
+    # Solutions and references
+    lines.append(f'  <solution>{alert_template["solution"]}</solution>\n')
+    
+    if "otherinfo" in alert_template:
+        lines.append(f'  <otherinfo>{alert_template["otherinfo"]}</otherinfo>\n')
+    
+    lines.append(f'  <reference>{alert_template["reference"]}</reference>\n')
+    lines.append(f'  <cweid>{alert_template["cweid"]}</cweid>\n')
+    lines.append(f'  <wascid>{alert_template["wascid"]}</wascid>\n')
+    lines.append(f'  <sourceid>3</sourceid>\n')
+    lines.append('</alertitem>\n')
+    
+    return lines
+
+
+def get_low_risk_alerts():
+    """Return low-risk security alerts."""
+    return [
+        {
+            "pluginid": "10021",
+            "name": "X-Content-Type-Options Header Missing",
+            "riskcode": "1",
+            "confidence": "2",
+            "riskdesc": "Low (Medium)",
+            "desc": "&lt;p&gt;The Anti-MIME-Sniffing header X-Content-Type-Options was not set to &apos;nosniff&apos;. This allows older versions of Internet Explorer and Chrome to perform MIME-sniffing on the response body, potentially causing the response body to be interpreted and displayed as a content type other than the declared content type. Current (early 2014) and legacy versions of Firefox will use the declared content type (if one is set), rather than performing MIME-sniffing.&lt;/p&gt;",
+            "param": "X-Content-Type-Options",
+            "max_instances": 5,
+            "paths": ["/", "/demo.css", "/welcome.html", "/error.html"],
+            "solution": "&lt;p&gt;Ensure that the application/web server sets the Content-Type header appropriately, and that it sets the X-Content-Type-Options header to &apos;nosniff&apos; for all web pages.&lt;/p&gt;&lt;p&gt;If possible, ensure that the end user uses a standards-compliant and modern web browser that does not perform MIME-sniffing at all, or that can be directed by the web application/web server to not perform MIME-sniffing.&lt;/p&gt;",
+            "otherinfo": "&lt;p&gt;This issue still applies to error type pages (401, 403, 500, etc) as those pages are often still affected by injection issues, in which case there is still concern for browsers sniffing pages away from their actual content type.&lt;/p&gt;&lt;p&gt;At &quot;High&quot; threshold this scanner will not alert on client or server error responses.&lt;/p&gt;",
+            "reference": "&lt;p&gt;http://msdn.microsoft.com/en-us/library/ie/gg622941%28v=vs.85%29.aspx&lt;/p&gt;&lt;p&gt;https://www.owasp.org/index.php/List_of_useful_HTTP_headers&lt;/p&gt;",
+            "cweid": "16",
+            "wascid": "15",
+        },
+        {
+            "pluginid": "10016",
+            "name": "Web Browser XSS Protection Not Enabled",
+            "riskcode": "1",
+            "confidence": "2",
+            "riskdesc": "Low (Medium)",
+            "desc": "&lt;p&gt;Web Browser XSS Protection is not enabled, or is disabled by the configuration of the &apos;X-XSS-Protection&apos; HTTP response header on the web server&lt;/p&gt;",
+            "param": "X-XSS-Protection",
+            "max_instances": 7,
+            "paths": ["/", "/welcome.html", "/error.html", "/favicon.ico", "/robots.txt", "/sitemap.xml"],
+            "solution": "&lt;p&gt;Ensure that the web browser&apos;s XSS filter is enabled, by setting the X-XSS-Protection HTTP response header to &apos;1&apos;.&lt;/p&gt;",
+            "otherinfo": "&lt;p&gt;The X-XSS-Protection HTTP response header allows the web server to enable or disable the web browser&apos;s XSS protection mechanism. The following values would attempt to enable it: &lt;/p&gt;&lt;p&gt;X-XSS-Protection: 1; mode=block&lt;/p&gt;&lt;p&gt;X-XSS-Protection: 1; report=http://www.example.com/xss&lt;/p&gt;&lt;p&gt;The following values would disable it:&lt;/p&gt;&lt;p&gt;X-XSS-Protection: 0&lt;/p&gt;&lt;p&gt;The X-XSS-Protection HTTP response header is currently supported on Internet Explorer, Chrome and Safari (WebKit).&lt;/p&gt;&lt;p&gt;Note that this alert is only raised if the response body could potentially contain an XSS payload (with a text-based content type, with a non-zero length).&lt;/p&gt;",
+            "reference": "&lt;p&gt;https://www.owasp.org/index.php/XSS_(Cross_Site_Scripting)_Prevention_Cheat_Sheet&lt;/p&gt;&lt;p&gt;https://blog.veracode.com/2014/03/guidelines-for-setting-security-headers/&lt;/p&gt;",
+            "cweid": "933",
+            "wascid": "14",
+        },
+        {
+            "pluginid": "10012",
+            "name": "Password Autocomplete in Browser",
+            "riskcode": "1",
+            "confidence": "2",
+            "riskdesc": "Low (Medium)",
+            "desc": "&lt;p&gt;The AUTOCOMPLETE attribute is not disabled on an HTML FORM/INPUT element containing password type input.  Passwords may be stored in browsers and retrieved.&lt;/p&gt;",
+            "param": "password_field",
+            "max_instances": 2,
+            "paths": ["/", "/login"],
+            "evidence": "&lt;input id=&quot;password_field&quot; size=&quot;30&quot; type=&quot;password&quot;&gt;",
+            "solution": "&lt;p&gt;Turn off the AUTOCOMPLETE attribute in forms or individual input elements containing password inputs by using AUTOCOMPLETE=&apos;OFF&apos;.&lt;/p&gt;",
+            "reference": "&lt;p&gt;http://www.w3schools.com/tags/att_input_autocomplete.asp&lt;/p&gt;&lt;p&gt;https://msdn.microsoft.com/en-us/library/ms533486%28v=vs.85%29.aspx&lt;/p&gt;",
+            "cweid": "525",
+            "wascid": "15",
+        },
+    ]
+
+
+def get_high_risk_alerts():
+    """Return high-risk security alerts."""
+    return [
+        {
+            "pluginid": "40018",
+            "name": "SQL Injection",
+            "riskcode": "3",
+            "confidence": "3",
+            "riskdesc": "High (High)",
+            "desc": "&lt;p&gt;SQL injection may be possible.&lt;/p&gt;",
+            "param": "id",
+            "max_instances": 3,
+            "paths": ["/api/users", "/search", "/products"],
+            "evidence": "You have an error in your SQL syntax",
+            "solution": "&lt;p&gt;Use prepared statements and parameterized queries.&lt;/p&gt;",
+            "reference": "&lt;p&gt;https://www.owasp.org/index.php/SQL_Injection&lt;/p&gt;",
+            "cweid": "89",
+            "wascid": "19",
+        },
+        {
+            "pluginid": "40012",
+            "name": "Cross Site Scripting (Reflected)",
+            "riskcode": "3",
+            "confidence": "2",
+            "riskdesc": "High (Medium)",
+            "desc": "&lt;p&gt;Cross-site Scripting (XSS) is possible.&lt;/p&gt;",
+            "param": "query",
+            "max_instances": 2,
+            "paths": ["/search", "/comment"],
+            "evidence": "&lt;script&gt;alert(1)&lt;/script&gt;",
+            "solution": "&lt;p&gt;Validate all input and encode all output.&lt;/p&gt;",
+            "reference": "&lt;p&gt;https://www.owasp.org/index.php/XSS&lt;/p&gt;",
+            "cweid": "79",
+            "wascid": "8",
+        },
+        {
+            "pluginid": "10020",
+            "name": "X-Frame-Options Header Not Set",
+            "riskcode": "2",
+            "confidence": "2",
+            "riskdesc": "Medium (Medium)",
+            "desc": "&lt;p&gt;X-Frame-Options header is not included in the HTTP response to protect against &apos;ClickJacking&apos; attacks.&lt;/p&gt;",
+            "param": "X-Frame-Options",
+            "max_instances": 4,
+            "paths": ["/", "/welcome.html", "/error.html"],
+            "solution": "&lt;p&gt;Most modern Web browsers support the X-Frame-Options HTTP header. Ensure it&apos;s set on all web pages returned by your site (if you expect the page to be framed only by pages on your server (e.g. it&apos;s part of a FRAMESET) then you&apos;ll want to use SAMEORIGIN, otherwise if you never expect the page to be framed, you should use DENY. ALLOW-FROM allows specific websites to frame the web page in supported web browsers).&lt;/p&gt;",
+            "reference": "&lt;p&gt;http://blogs.msdn.com/b/ieinternals/archive/2010/03/30/combating-clickjacking-with-x-frame-options.aspx&lt;/p&gt;",
+            "cweid": "16",
+            "wascid": "15",
+        },
+    ]
+
+
+def get_mixed_risk_alerts():
+    """Return mix of risk levels."""
+    return get_low_risk_alerts() + [
+        {
+            "pluginid": "10020",
+            "name": "X-Frame-Options Header Not Set",
+            "riskcode": "2",
+            "confidence": "2",
+            "riskdesc": "Medium (Medium)",
+            "desc": "&lt;p&gt;X-Frame-Options header is not included in the HTTP response to protect against &apos;ClickJacking&apos; attacks.&lt;/p&gt;",
+            "param": "X-Frame-Options",
+            "max_instances": 4,
+            "paths": ["/", "/welcome.html", "/error.html"],
+            "solution": "&lt;p&gt;Most modern Web browsers support the X-Frame-Options HTTP header. Ensure it&apos;s set on all web pages returned by your site (if you expect the page to be framed only by pages on your server (e.g. it&apos;s part of a FRAMESET) then you&apos;ll want to use SAMEORIGIN, otherwise if you never expect the page to be framed, you should use DENY. ALLOW-FROM allows specific websites to frame the web page in supported web browsers).&lt;/p&gt;",
+            "reference": "&lt;p&gt;http://blogs.msdn.com/b/ieinternals/archive/2010/03/30/combating-clickjacking-with-x-frame-options.aspx&lt;/p&gt;",
+            "cweid": "16",
+            "wascid": "15",
+        },
+    ]

robotmk_bridge_testdatagenerator-0.3.0/src/robotmk_bridge_testdatagenerator/handlers.yaml

@@ -0,0 +1,53 @@
+# handlers.yaml — Central registry of supported Robotmk Bridge handlers.
+#
+# This file is the single source of truth for:
+#   1. The Bakery UI (handler dropdown choices + per-handler parameter fields),
+#      generated by scripts/generate_bakery_handler_fields.py.
+#   2. The test data generator (tests/data_generator/).
+#
+# Fields per handler:
+#   name:         Internal key; must match the handler name expected by RobotmkBridgeCore.
+#   title:        Human-readable name shown in the Bakery UI.
+#   class_import: Fully qualified Python class path (for introspection).
+#   result_ext:   Typical file extension of result files produced by this tool.
+#   description:  Short one-liner for documentation purposes.
+
+handlers:
+  - name: junit
+    title: JUnit
+    class_import: rmkbridge.junit.JUnitHandler
+    result_ext: xml
+    description: >
+      Parses JUnit XML result files produced by any JUnit-compatible
+      test framework (pytest, Maven Surefire, NUnit, etc.).
+
+  - name: gatling
+    title: Gatling
+    class_import: rmkbridge.gatling.GatlingHandler
+    result_ext: log
+    description: >
+      Parses Gatling simulation log files (simulation.log) produced
+      by Gatling performance testing runs.
+
+  - name: zaproxy
+    title: OWASP ZAP (Zed Attack Proxy)
+    class_import: rmkbridge.zap.ZAProxyHandler
+    result_ext: xml
+    description: >
+      Parses OWASP ZAP security scan result files (XML or JSON format).
+      Supports filtering by accepted_risk_level and required_confidence_level.
+    handler_params:
+      - name: accepted_risk_level
+        type: int
+        required: false
+        default: null
+        description: >
+          Minimum risk level of alerts to include (0=Info, 1=Low, 2=Medium, 3=High).
+          Alerts below this level are ignored.
+      - name: required_confidence_level
+        type: int
+        required: false
+        default: null
+        description: >
+          Minimum confidence level of alerts to include (1=Low, 2=Medium, 3=High).
+          Alerts below this confidence are ignored.