overload-cli 0.1.0__py3-none-any.whl

overload/collection/parser.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from collections.abc import Generator
+from typing import Any
+
+from overload.collection.models import (
+    AuthConfig,
+    CollectionVariable,
+    ParsedCollection,
+    ParsedRequest,
+    QueryParam,
+    RequestBody,
+)
+
+SUPPORTED_SCHEMA_VERSIONS = ("v2.1.0", "v2.0.0")
+
+
+def parse_collection(source: str | Path | dict) -> ParsedCollection:
+    if isinstance(source, dict):
+        data = source
+    else:
+        path = Path(source)
+        if not path.exists():
+            raise FileNotFoundError(f"Collection file not found: {path}")
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+
+    _validate_schema(data)
+
+    info = data.get("info", {})
+    collection_auth = _parse_auth(data.get("auth"))
+    collection_vars = [
+        CollectionVariable(
+            key=v.get("key", ""),
+            value=v.get("value", ""),
+            type=v.get("type", "string"),
+        )
+        for v in data.get("variable", [])
+    ]
+
+    requests = list(
+        _flatten_items(data.get("item", []), path=[], parent_auth=collection_auth)
+    )
+
+    return ParsedCollection(
+        name=info.get("name", "Unnamed Collection"),
+        description=info.get("description", ""),
+        requests=requests,
+        variables=collection_vars,
+        auth=collection_auth,
+    )
+
+
+def _validate_schema(data: dict) -> None:
+    schema = data.get("info", {}).get("schema", "")
+    if not any(version in schema for version in SUPPORTED_SCHEMA_VERSIONS):
+        if not data.get("info", {}).get("name"):
+            raise ValueError(
+                "Invalid collection format. Expected a Postman Collection v2.x JSON file."
+            )
+
+
+def _flatten_items(
+    items: list[dict],
+    path: list[str],
+    parent_auth: AuthConfig | None,
+) -> Generator[ParsedRequest, None, None]:
+    for item in items:
+        if "item" in item and "request" not in item:
+            folder_name = item.get("name", "Unnamed Folder")
+            folder_auth = _parse_auth(item.get("auth")) or parent_auth
+            yield from _flatten_items(
+                item["item"], path=path + [folder_name], parent_auth=folder_auth
+            )
+        elif "request" in item:
+            yield _parse_request(item, path, parent_auth)
+
+
+def _parse_request(
+    item: dict, folder_path: list[str], inherited_auth: AuthConfig | None
+) -> ParsedRequest:
+    req = item["request"]
+
+    if isinstance(req, str):
+        return ParsedRequest(
+            name=item.get("name", "Unnamed Request"),
+            method="GET",
+            url_raw=req,
+            folder_path=folder_path,
+        )
+
+    method = req.get("method", "GET").upper()
+    url_raw, query_params = _parse_url(req.get("url", ""))
+    headers = _parse_headers(req.get("header", []))
+    body = _parse_body(req.get("body"))
+    auth = _parse_auth(req.get("auth")) or inherited_auth
+
+    return ParsedRequest(
+        name=item.get("name", "Unnamed Request"),
+        method=method,
+        url_raw=url_raw,
+        headers=headers,
+        body=body,
+        auth=auth,
+        query_params=query_params,
+        folder_path=folder_path,
+    )
+
+
+def _parse_url(url: Any) -> tuple[str, list[QueryParam]]:
+    if isinstance(url, str):
+        return url, []
+
+    if isinstance(url, dict):
+        raw = url.get("raw", "")
+        query_params = [
+            QueryParam(
+                key=q.get("key", ""),
+                value=q.get("value", ""),
+                disabled=q.get("disabled", False),
+            )
+            for q in url.get("query", [])
+        ]
+
+        if not raw:
+            protocol = url.get("protocol", "https")
+            host = ".".join(url.get("host", []))
+            path = "/".join(url.get("path", []))
+            raw = f"{protocol}://{host}"
+            if path:
+                raw += f"/{path}"
+
+        return raw, query_params
+
+    return str(url), []
+
+
+def _parse_headers(headers: list[dict] | None) -> dict[str, str]:
+    if not headers:
+        return {}
+    return {
+        h["key"]: h.get("value", "")
+        for h in headers
+        if not h.get("disabled", False) and "key" in h
+    }
+
+
+def _parse_body(body: dict | None) -> RequestBody:
+    if not body:
+        return RequestBody(mode="none")
+
+    mode = body.get("mode", "none")
+
+    if mode == "raw":
+        content = body.get("raw", "")
+        lang = body.get("options", {}).get("raw", {}).get("language", "json")
+        content_type_map = {
+            "json": "application/json",
+            "xml": "application/xml",
+            "text": "text/plain",
+            "html": "text/html",
+            "javascript": "application/javascript",
+        }
+        return RequestBody(
+            mode="raw",
+            content=content,
+            content_type=content_type_map.get(lang, "text/plain"),
+        )
+
+    if mode == "formdata":
+        fields = [
+            {"key": f["key"], "value": f.get("value", ""), "type": f.get("type", "text")}
+            for f in body.get("formdata", [])
+            if not f.get("disabled", False)
+        ]
+        return RequestBody(mode="formdata", content=fields)
+
+    if mode == "urlencoded":
+        fields = [
+            {"key": f["key"], "value": f.get("value", "")}
+            for f in body.get("urlencoded", [])
+            if not f.get("disabled", False)
+        ]
+        return RequestBody(
+            mode="urlencoded",
+            content=fields,
+            content_type="application/x-www-form-urlencoded",
+        )
+
+    if mode == "graphql":
+        gql = body.get("graphql", {})
+        return RequestBody(
+            mode="graphql",
+            content={"query": gql.get("query", ""), "variables": gql.get("variables", "{}")},
+            content_type="application/json",
+        )
+
+    if mode == "file":
+        src = body.get("file", {}).get("src", "")
+        return RequestBody(mode="file", content=src)
+
+    return RequestBody(mode="none")
+
+
+def _parse_auth(auth: dict | None) -> AuthConfig | None:
+    if not auth:
+        return None
+
+    auth_type = auth.get("type", "noauth")
+    if auth_type == "noauth":
+        return None
+
+    params: dict[str, str] = {}
+    for item in auth.get(auth_type, []):
+        if isinstance(item, dict) and "key" in item:
+            params[item["key"]] = item.get("value", "")
+
+    return AuthConfig(type=auth_type, params=params)

overload/collection/variables.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import logging
+import random
+import re
+import time
+import uuid
+
+from overload.collection.models import CollectionVariable
+
+logger = logging.getLogger(__name__)
+
+VARIABLE_PATTERN = re.compile(r"\{\{([^}]+)\}\}")
+
+DYNAMIC_VARIABLES: dict[str, callable] = {
+    "$randomInt": lambda: str(random.randint(0, 1000)),
+    "$timestamp": lambda: str(int(time.time())),
+    "$guid": lambda: str(uuid.uuid4()),
+    "$randomBoolean": lambda: random.choice(["true", "false"]),
+    "$randomColor": lambda: random.choice(["red", "blue", "green", "yellow", "purple"]),
+    "$randomFirstName": lambda: random.choice(["John", "Jane", "Alice", "Bob", "Charlie"]),
+    "$randomEmail": lambda: f"user{random.randint(1, 9999)}@example.com",
+}
+
+
+class VariableContext:
+    def __init__(
+        self,
+        collection_vars: list[CollectionVariable] | None = None,
+        environment_vars: dict[str, str] | None = None,
+        runtime_vars: dict[str, str] | None = None,
+    ) -> None:
+        self._scopes: list[dict[str, str]] = [
+            runtime_vars or {},
+            environment_vars or {},
+            {v.key: v.value for v in (collection_vars or [])},
+        ]
+        self._unresolved: set[str] = set()
+
+    @property
+    def unresolved(self) -> set[str]:
+        return self._unresolved.copy()
+
+    def set_variable(self, key: str, value: str) -> None:
+        self._scopes[0][key] = value
+
+    def get_variable(self, key: str) -> str | None:
+        for scope in self._scopes:
+            if key in scope:
+                return scope[key]
+        return None
+
+    def get_all_variables(self) -> dict[str, str]:
+        merged: dict[str, str] = {}
+        for scope in reversed(self._scopes):
+            merged.update(scope)
+        return merged
+
+    def resolve(self, template: str) -> str:
+        if not template or "{{" not in template:
+            return template
+
+        def _replacer(match: re.Match) -> str:
+            var_name = match.group(1).strip()
+
+            if var_name in DYNAMIC_VARIABLES:
+                return DYNAMIC_VARIABLES[var_name]()
+
+            for scope in self._scopes:
+                if var_name in scope:
+                    value = scope[var_name]
+                    return self.resolve(value) if "{{" in value else value
+
+            self._unresolved.add(var_name)
+            logger.warning("Unresolved variable: {{%s}}", var_name)
+            return match.group(0)
+
+        return VARIABLE_PATTERN.sub(_replacer, template)
+
+    def resolve_dict(self, d: dict[str, str]) -> dict[str, str]:
+        return {self.resolve(k): self.resolve(v) for k, v in d.items()}
+
+    def resolve_url(self, url: str) -> str:
+        return self.resolve(url)

overload/config_file.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from overload.engine.models import Threshold
+
+logger = logging.getLogger(__name__)
+
+CONFIG_FILENAME = "overload.config.yaml"
+
+
+def load_config(path: str | Path) -> dict[str, Any]:
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Config file not found: {path}")
+
+    with open(path, encoding="utf-8") as f:
+        raw = yaml.safe_load(f)
+
+    if not isinstance(raw, dict):
+        raise ValueError(f"Config file must contain a YAML mapping, got {type(raw).__name__}")
+
+    return raw
+
+
+def save_config(
+    path: str | Path,
+    test_type: str,
+    config: dict[str, Any],
+    thresholds: list[Threshold] | None = None,
+) -> str:
+    data: dict[str, Any] = {
+        "test_type": test_type,
+        "config": config,
+    }
+
+    if thresholds:
+        data["thresholds"] = [
+            {"metric": t.metric, "operator": t.operator, "value": t.value}
+            for t in thresholds
+        ]
+
+    path = Path(path)
+    with open(path, "w", encoding="utf-8") as f:
+        yaml.safe_dump(data, f, default_flow_style=False, sort_keys=False)
+
+    logger.info("Config saved to %s", path)
+    return str(path)
+
+
+def extract_thresholds(raw: dict[str, Any]) -> list[Threshold]:
+    thresholds: list[Threshold] = []
+    for entry in raw.get("thresholds", []):
+        if not isinstance(entry, dict):
+            continue
+        thresholds.append(Threshold(
+            metric=entry["metric"],
+            operator=entry["operator"],
+            value=float(entry["value"]),
+        ))
+    return thresholds
+
+
+def extract_config(raw: dict[str, Any]) -> dict[str, Any]:
+    return raw.get("config", {})
+
+
+def extract_test_type(raw: dict[str, Any]) -> str | None:
+    return raw.get("test_type")

overload/engine/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

overload/engine/assertions.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import logging
+import operator as op
+import xml.etree.ElementTree as ET
+from typing import Callable
+
+from overload.engine.models import AssertionResult, Threshold, Verdict
+
+logger = logging.getLogger(__name__)
+
+_OPERATORS: dict[str, Callable[[float, float], bool]] = {
+    "<": op.lt,
+    "<=": op.le,
+    ">": op.gt,
+    ">=": op.ge,
+    "==": op.eq,
+}
+
+_METRIC_EXTRACTORS: dict[str, Callable[[dict], float | None]] = {
+    "p50_latency_ms": lambda s: s.get("latency", {}).get("median"),
+    "p95_latency_ms": lambda s: s.get("latency", {}).get("p95"),
+    "p99_latency_ms": lambda s: s.get("latency", {}).get("p99"),
+    "max_latency_ms": lambda s: s.get("latency", {}).get("max"),
+    "mean_latency_ms": lambda s: s.get("latency", {}).get("mean"),
+    "error_rate_pct": lambda s: (
+        (s["errors"] / s["total"]) * 100 if s.get("total", 0) > 0 else 0.0
+    ),
+    "success_rate_pct": lambda s: (
+        (s["ok"] / s["total"]) * 100 if s.get("total", 0) > 0 else 0.0
+    ),
+    "avg_rps": lambda s: s.get("avg_rps"),
+    "total_requests": lambda s: float(s["total"]) if "total" in s else None,
+    "rate_limited_count": lambda s: float(s.get("rate_limited", 0)),
+}
+
+
+def evaluate(computed: dict, thresholds: list[Threshold]) -> Verdict:
+    results: list[AssertionResult] = []
+
+    for threshold in thresholds:
+        extractor = _METRIC_EXTRACTORS.get(threshold.metric)
+        if extractor is None:
+            logger.warning("Unknown metric: %s — skipping assertion", threshold.metric)
+            results.append(AssertionResult(
+                metric=threshold.metric,
+                operator=threshold.operator,
+                expected=threshold.value,
+                actual=float("nan"),
+                passed=False,
+            ))
+            continue
+
+        actual = extractor(computed)
+        if actual is None:
+            logger.warning("Metric %s not available in stats", threshold.metric)
+            results.append(AssertionResult(
+                metric=threshold.metric,
+                operator=threshold.operator,
+                expected=threshold.value,
+                actual=float("nan"),
+                passed=False,
+            ))
+            continue
+
+        comparator = _OPERATORS.get(threshold.operator)
+        if comparator is None:
+            logger.error("Invalid operator: %s", threshold.operator)
+            results.append(AssertionResult(
+                metric=threshold.metric,
+                operator=threshold.operator,
+                expected=threshold.value,
+                actual=actual,
+                passed=False,
+            ))
+            continue
+
+        passed = comparator(actual, threshold.value)
+        results.append(AssertionResult(
+            metric=threshold.metric,
+            operator=threshold.operator,
+            expected=threshold.value,
+            actual=actual,
+            passed=passed,
+        ))
+
+    return Verdict(
+        passed=all(r.passed for r in results),
+        results=results,
+    )
+
+
+def parse_threshold(expr: str) -> Threshold:
+    for symbol in ("<=", ">=", "==", "<", ">"):
+        if symbol in expr:
+            metric, value_str = expr.split(symbol, 1)
+            return Threshold(
+                metric=metric.strip(),
+                operator=symbol,
+                value=float(value_str.strip()),
+            )
+    raise ValueError(f"Invalid threshold expression: {expr!r}")
+
+
+def _format_value(metric: str, value: float) -> str:
+    if "latency" in metric:
+        return f"{value:.1f}ms"
+    if "pct" in metric:
+        return f"{value:.1f}%"
+    if "rps" in metric:
+        return f"{value:.1f}/s"
+    if value == int(value):
+        return str(int(value))
+    return f"{value:.1f}"
+
+
+def print_verdict(verdict: Verdict) -> None:
+    print("\n  Assertions:")
+    for r in verdict.results:
+        mark = "\033[32m✓\033[0m" if r.passed else "\033[31m✗\033[0m"
+        actual_str = _format_value(r.metric, r.actual)
+        expected_str = _format_value(r.metric, r.expected)
+        print(f"    {mark} {r.metric}  {actual_str} {r.operator} {expected_str}")
+
+    label = "\033[32mPASS\033[0m" if verdict.passed else "\033[31mFAIL\033[0m"
+    print(f"\n  Verdict: {label}")
+
+
+def write_junit_xml(verdict: Verdict, path: str, test_name: str = "overload") -> None:
+    suite = ET.Element("testsuite", {
+        "name": test_name,
+        "tests": str(len(verdict.results)),
+        "failures": str(sum(1 for r in verdict.results if not r.passed)),
+    })
+
+    for r in verdict.results:
+        case = ET.SubElement(suite, "testcase", {
+            "name": f"{r.metric} {r.operator} {_format_value(r.metric, r.expected)}",
+            "classname": "overload.assertions",
+        })
+        if not r.passed:
+            failure = ET.SubElement(case, "failure", {
+                "message": (
+                    f"{r.metric}: expected {r.operator} {_format_value(r.metric, r.expected)}, "
+                    f"got {_format_value(r.metric, r.actual)}"
+                ),
+            })
+
+    tree = ET.ElementTree(suite)
+    ET.indent(tree)
+    tree.write(path, encoding="unicode", xml_declaration=True)

overload/engine/auth.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass
+
+import httpx
+
+from overload.collection.models import AuthConfig
+from overload.collection.variables import VariableContext
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class _CachedToken:
+    token: str
+    expires_at: float
+
+
+_TOKEN_CACHE: dict[str, _CachedToken] = {}
+
+
+async def fetch_oauth2_token(
+    auth: AuthConfig,
+    ctx: VariableContext,
+    client: httpx.AsyncClient,
+) -> str:
+    params = auth.params
+
+    # Postman uses "accessTokenUrl"; some environments expose it as "access_token_url"
+    token_url = ctx.resolve(
+        params.get("accessTokenUrl")
+        or params.get("access_token_url")
+        or params.get("tokenUrl")
+        or ""
+    )
+    client_id = ctx.resolve(params.get("clientId") or params.get("client_id") or "")
+    client_secret = ctx.resolve(params.get("clientSecret") or params.get("client_secret") or "")
+    scope = ctx.resolve(params.get("scope") or "")
+
+    if not token_url:
+        raise ValueError("OAuth2 auth: accessTokenUrl is required but missing")
+
+    cache_key = f"{client_id}:{token_url}"
+    cached = _TOKEN_CACHE.get(cache_key)
+    if cached and cached.expires_at > time.time() + 30:
+        logger.debug("OAuth2: using cached token for client_id=%s", client_id)
+        return cached.token
+
+    logger.info("OAuth2: fetching token from %s (client_id=%s)", token_url, client_id)
+
+    post_data: dict[str, str] = {
+        "grant_type": "client_credentials",
+        "client_id": client_id,
+        "client_secret": client_secret,
+    }
+    if scope:
+        post_data["scope"] = scope
+
+    try:
+        response = await client.post(token_url, data=post_data)
+        response.raise_for_status()
+        body = response.json()
+    except httpx.HTTPStatusError as exc:
+        raise RuntimeError(
+            f"OAuth2 token request failed: {exc.response.status_code} — {exc.response.text}"
+        ) from exc
+    except Exception as exc:
+        raise RuntimeError(f"OAuth2 token request failed: {exc}") from exc
+
+    access_token: str | None = body.get("access_token")
+    if not access_token:
+        raise RuntimeError(f"OAuth2 response missing 'access_token' field: {body}")
+
+    expires_in = int(body.get("expires_in", 3600))
+    _TOKEN_CACHE[cache_key] = _CachedToken(
+        token=access_token,
+        expires_at=time.time() + expires_in,
+    )
+
+    logger.info("OAuth2: token acquired, expires in %ds", expires_in)
+    return access_token
+
+
+def clear_token_cache() -> None:
+    _TOKEN_CACHE.clear()

overload/engine/events.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections import defaultdict
+from collections.abc import Callable
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class EventBus:
+    def __init__(self) -> None:
+        self._handlers: dict[str, list[Callable]] = defaultdict(list)
+        self._queues: dict[str, list[asyncio.Queue]] = defaultdict(list)
+
+    def subscribe(self, event: str, handler: Callable) -> None:
+        self._handlers[event].append(handler)
+
+    def unsubscribe(self, event: str, handler: Callable) -> None:
+        handlers = self._handlers.get(event, [])
+        if handler in handlers:
+            handlers.remove(handler)
+
+    def create_queue(self, event: str) -> asyncio.Queue:
+        queue: asyncio.Queue = asyncio.Queue()
+        self._queues[event].append(queue)
+        return queue
+
+    def remove_queue(self, event: str, queue: asyncio.Queue) -> None:
+        queues = self._queues.get(event, [])
+        if queue in queues:
+            queues.remove(queue)
+
+    async def emit(self, event: str, data: Any = None) -> None:
+        logger.debug("Event emitted: %s", event)
+
+        for handler in self._handlers.get(event, []):
+            try:
+                result = handler(data)
+                if asyncio.iscoroutine(result):
+                    await result
+            except Exception:
+                logger.exception("Error in event handler for %s", event)
+
+        for queue in self._queues.get(event, []):
+            try:
+                queue.put_nowait({"event": event, "data": data})
+            except asyncio.QueueFull:
+                logger.warning("Event queue full for %s, dropping event", event)