ai-testing-swarm 0.1.1__py3-none-any.whl → 0.1.11__py3-none-any.whl

ai_testing_swarm/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.0"
+__version__ = "0.1.11"

ai_testing_swarm/agents/execution_agent.py

@@ -1,64 +1,186 @@
-import requests
+import random
+import time
 from copy import deepcopy
 
+import requests
+
+from ai_testing_swarm.core.config import (
+    AI_SWARM_RETRY_BACKOFF_MS,
+    AI_SWARM_RETRY_COUNT,
+    AI_SWARM_RPS,
+)
+
 
 class ExecutionAgent:
+    def _set_path(self, obj: dict, path: list[str], value, remove: bool = False):
+        """Set/remove nested key in a dict. Creates intermediate dicts if needed."""
+        if not path:
+            return
+        cur = obj
+        for key in path[:-1]:
+            if key not in cur or not isinstance(cur[key], dict):
+                cur[key] = {}
+            cur = cur[key]
+
+        last = path[-1]
+        if remove:
+            cur.pop(last, None)
+        else:
+            cur[last] = value
+
     def apply_mutation(self, data: dict, mutation: dict):
         if not mutation:
             return deepcopy(data)
 
         data = deepcopy(data)
-        key = mutation["path"][0]
-        op = mutation["operation"]
+        path = mutation.get("path") or []
+        op = mutation.get("operation")
 
         if op == "REMOVE":
-            data.pop(key, None)
+            self._set_path(data, path, None, remove=True)
         elif op == "REPLACE":
-            data[key] = mutation["new_value"]
+            self._set_path(data, path, mutation.get("new_value"), remove=False)
 
         return data
 
+    def _throttle(self):
+        # Optional global throttling to avoid hammering target services.
+        if AI_SWARM_RPS and AI_SWARM_RPS > 0:
+            time.sleep(1.0 / float(AI_SWARM_RPS))
+
+    def _should_retry(self, status_code: int | None, error: str | None) -> bool:
+        if error:
+            return True
+        if status_code in (408, 425, 429, 500, 502, 503, 504):
+            return True
+        return False
+
     def execute(self, request: dict, test: dict):
         mutation = test.get("mutation")
 
+        # Method (allow method mutations)
+        method = request["method"].upper()
+        if mutation and mutation.get("target") == "method" and mutation.get("operation") == "REPLACE":
+            method = str(mutation.get("new_value") or method).upper()
+
         params = (
-            self.apply_mutation(request.get("params", {}), mutation)
+            self.apply_mutation(request.get("params", {}) or {}, mutation)
             if mutation and mutation.get("target") == "query"
-            else deepcopy(request.get("params", {}))
+            else deepcopy(request.get("params", {}) or {})
         )
 
-        body = (
-            self.apply_mutation(request.get("body", {}), mutation)
-            if mutation and mutation.get("target") == "body"
-            else deepcopy(request.get("body", {}))
-        )
+        body = deepcopy(request.get("body", {}) or {})
+        if mutation and mutation.get("target") == "body":
+            body = self.apply_mutation(body, mutation)
+        elif mutation and mutation.get("target") == "body_whole" and mutation.get("operation") == "REPLACE":
+            body = mutation.get("new_value")
 
-        response = requests.request(
-            method=request["method"],
-            url=request["url"],
-            headers=request["headers"],
-            params=params or None,
-            json=None if request["method"] == "GET" else body,
-            timeout=10,
-        )
+        headers = deepcopy(request.get("headers", {}) or {})
+        if mutation and mutation.get("target") == "headers":
+            headers = self.apply_mutation(headers, mutation)
+
+        # Payload strategy (basic content-type aware)
+        send_json = method != "GET"
+        ct = (headers.get("content-type") or headers.get("Content-Type") or "").lower()
+
+        json_payload = None
+        data_payload = None
+        if method == "GET":
+            json_payload = None
+            data_payload = None
+        else:
+            # If body is not a dict, send raw data
+            if not isinstance(body, (dict, list)):
+                send_json = False
+                data_payload = body
+            elif "application/x-www-form-urlencoded" in ct:
+                send_json = False
+                data_payload = body
+            else:
+                json_payload = body
+
+        # Execute with light retry/backoff on transient failures.
+        attempt = 0
+        last_error = None
+        last_response = None
+
+        while True:
+            attempt += 1
+            self._throttle()
+
+            started = time.time()
+            try:
+                resp = requests.request(
+                    method=method,
+                    url=request["url"],
+                    headers=headers,
+                    params=params or None,
+                    json=json_payload if send_json else None,
+                    data=data_payload if not send_json else None,
+                    timeout=15,
+                )
+                elapsed_ms = int((time.time() - started) * 1000)
+
+                last_error = None
+                last_response = (resp, elapsed_ms)
+
+                if attempt <= (AI_SWARM_RETRY_COUNT + 1) and self._should_retry(resp.status_code, None):
+                    # jittered backoff
+                    backoff = (AI_SWARM_RETRY_BACKOFF_MS / 1000.0) * (2 ** (attempt - 1))
+                    backoff = backoff * (0.75 + random.random() * 0.5)
+                    time.sleep(min(backoff, 5.0))
+                    if attempt <= AI_SWARM_RETRY_COUNT:
+                        continue
+
+                try:
+                    body_snippet = resp.json()
+                except Exception:
+                    body_snippet = resp.text
+
+                return {
+                    "name": test["name"],
+                    "mutation": mutation,
+                    "request": {
+                        "method": method,
+                        "url": request["url"],
+                        "headers": headers,
+                        "params": params,
+                        "body": body if method != "GET" else None,
+                    },
+                    "response": {
+                        "status_code": resp.status_code,
+                        "elapsed_ms": elapsed_ms,
+                        "attempt": attempt,
+                        "body_snippet": body_snippet,
+                    },
+                }
+
+            except requests.RequestException as e:
+                elapsed_ms = int((time.time() - started) * 1000)
+                last_error = str(e)
+                last_response = None
+
+                if attempt <= AI_SWARM_RETRY_COUNT and self._should_retry(None, last_error):
+                    backoff = (AI_SWARM_RETRY_BACKOFF_MS / 1000.0) * (2 ** (attempt - 1))
+                    backoff = backoff * (0.75 + random.random() * 0.5)
+                    time.sleep(min(backoff, 5.0))
+                    continue
 
-        try:
-            body_snippet = response.json()
-        except Exception:
-            body_snippet = response.text
-
-        return {
-            "name": test["name"],  # 🔥 CANONICAL
-            "mutation": mutation,
-            "request": {
-                "method": request["method"],
-                "url": request["url"],
-                "headers": request["headers"],
-                "params": params,
-                "body": body if request["method"] != "GET" else None,
-            },
-            "response": {
-                "status_code": response.status_code,
-                "body_snippet": body_snippet,
-            },
-        }
+                return {
+                    "name": test["name"],
+                    "mutation": mutation,
+                    "request": {
+                        "method": method,
+                        "url": request["url"],
+                        "headers": headers,
+                        "params": params,
+                        "body": body if method != "GET" else None,
+                    },
+                    "response": {
+                        "status_code": None,
+                        "elapsed_ms": elapsed_ms,
+                        "attempt": attempt,
+                        "error": last_error,
+                        "body_snippet": None,
+                    },
+                }

ai_testing_swarm/agents/learning_agent.py

@@ -2,6 +2,7 @@ import json
 import os
 
 DB = "memory/failure_memory.json"
+MAX_ENTRIES = 200
 
 
 class LearningAgent:
@@ -20,10 +21,11 @@ class LearningAgent:
                 # Corrupted file → reset
                 data = []
 
-        data.append({
-            "test": test_name,
-            "reason": reasoning
-        })
+        data.append({"test": test_name, "reason": reasoning})
+
+        # Keep file bounded
+        if len(data) > MAX_ENTRIES:
+            data = data[-MAX_ENTRIES:]
 
         with open(DB, "w") as f:
             json.dump(data, f, indent=2)