sefrone-api-e2e 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

sefrone_api_e2e/api_e2e_manager.py

@@ -27,9 +27,11 @@ class ApiE2ETestsManager:
         ApiE2ETestsManager.scenario_results = []
 
         p = Path(folder_path)
-        scenario_files = sorted([f.name for f in p.iterdir() if f.is_file() and f.suffix == ".yaml"]) 
+        scenario_files = sorted([f.name for f in p.iterdir() if f.is_file() and f.suffix == ".yaml"])
         total_start = time.time()
 
+        all_tests_passed = True
+
         for filename in scenario_files:
             yaml_file_path = os.path.join(folder_path, filename)
             scenario_name = os.path.splitext(filename)[0]
@@ -55,6 +57,7 @@ class ApiE2ETestsManager:
                         "steps": step_metrics,
                         "total_time": elapsed
                     })
+                    all_tests_passed = False
                     # mark remaining scenarios as skipped
                     remaining = scenario_files[scenario_files.index(filename)+1:]
                     for skipped_file in remaining:
@@ -76,6 +79,7 @@ class ApiE2ETestsManager:
                     "steps": step_metrics if 'step_metrics' in locals() else [],
                     "total_time": failed_elapsed
                 })
+                all_tests_passed = False
                 # mark remaining scenarios as skipped
                 remaining = scenario_files[scenario_files.index(filename)+1:]
                 for skipped_file in remaining:
@@ -90,7 +94,10 @@ class ApiE2ETestsManager:
 
         total_elapsed = time.time() - total_start
         print("\nAPI E2E tests completed.")
-        ApiE2ETestsManager.print_summary(total_elapsed)
+        ApiE2ETestsManager.print_summary(total_elapsed, all_tests_passed)
+
+        if not all_tests_passed:
+            exit(1)
 
     @staticmethod
     def read_env_value_from_file(env_file_path, env_var):
@@ -167,13 +174,100 @@ class ApiE2ETestsManager:
     @staticmethod
     def render_template(template_str, context, add_quotes=False):
         def resolve_path(expr, ctx):
-            parts = expr.split(".")
+            # Parse path with array indexing support: body.items[0].id and count(): body.items.count()
             val = ctx
-            for p in parts:
-                if isinstance(val, dict) and p in val:
-                    val = val[p]
+            current_path = ""
+            i = 0
+
+            while i < len(expr):
+                # Check for array index
+                if expr[i] == '[':
+                    # Find closing bracket
+                    end = expr.find(']', i)
+                    if end == -1:
+                        raise ValueError(f"Unclosed bracket in path: {expr}")
+
+                    # Extract index
+                    index_str = expr[i+1:end].strip()
+                    try:
+                        index = int(index_str)
+                    except ValueError:
+                        raise ValueError(f"Invalid array index '{index_str}' in path: {expr}")
+
+                    # Apply index
+                    if not isinstance(val, list):
+                        raise KeyError(f"Cannot index non-list at '{current_path}' in path: {expr}")
+                    if index < 0 or index >= len(val):
+                        raise KeyError(f"Index {index} out of range at '{current_path}' in path: {expr}")
+
+                    val = val[index]
+                    current_path += f"[{index}]"
+                    i = end + 1
+
+                    # Skip dot after bracket if present
+                    if i < len(expr) and expr[i] == '.':
+                        i += 1
+
+                # Check for dot separator
+                elif expr[i] == '.':
+                    i += 1
+
+                # Read property name or function call
                 else:
-                    raise KeyError(f"Cannot resolve '{expr}' in context: {p} not found")
+                    # Find next special char
+                    next_dot = expr.find('.', i)
+                    next_bracket = expr.find('[', i)
+                    next_paren = expr.find('(', i)
+
+                    # Determine end of property name
+                    candidates = [next_dot, next_bracket, next_paren]
+                    valid_candidates = [c for c in candidates if c != -1]
+
+                    if not valid_candidates:
+                        end_pos = len(expr)
+                    else:
+                        end_pos = min(valid_candidates)
+
+                    prop = expr[i:end_pos].strip()
+                    if prop:
+                        # Check if it's a function call
+                        if end_pos < len(expr) and expr[end_pos] == '(':
+                            # Handle count() function
+                            if prop == "count":
+                                # Find closing parenthesis
+                                close_paren = expr.find(')', end_pos)
+                                if close_paren == -1:
+                                    raise ValueError(f"Unclosed parenthesis in function call: {expr}")
+
+                                # Check if there are arguments (should be empty for count)
+                                args = expr[end_pos+1:close_paren].strip()
+                                if args:
+                                    raise ValueError(f"count() function does not accept arguments: {expr}")
+
+                                # Apply count on lists or dicts
+                                if isinstance(val, (list, dict)):
+                                    val = len(val)
+                                else:
+                                    raise KeyError(f"Cannot call count() on type {type(val).__name__} at '{current_path}' in path: {expr}")
+
+                                current_path += ".count()"
+                                i = close_paren + 1
+
+                                # Skip dot after parenthesis if present
+                                if i < len(expr) and expr[i] == '.':
+                                    i += 1
+                            else:
+                                raise ValueError(f"Unsupported function '{prop}()' in path: {expr}")
+                        # Regular property access
+                        elif isinstance(val, dict) and prop in val:
+                            val = val[prop]
+                            current_path += f".{prop}" if current_path and not current_path.endswith(']') else prop
+                            i = end_pos
+                        else:
+                            raise KeyError(f"Cannot resolve '{expr}' in context: property '{prop}' not found at '{current_path}'")
+                    else:
+                        i = end_pos
+
             return val
 
         def replacer(match):
@@ -208,6 +302,20 @@ class ApiE2ETestsManager:
 
         return ApiE2ETestsManager.STORED_PATTERN.sub(repl, expr)
 
+    @staticmethod
+    def substitute_stored_in_body(body, scenario_name):
+        """Recursively substitute stored variables in request body."""
+        if body is None:
+            return None
+        elif isinstance(body, dict):
+            return {k: ApiE2ETestsManager.substitute_stored_in_body(v, scenario_name) for k, v in body.items()}
+        elif isinstance(body, list):
+            return [ApiE2ETestsManager.substitute_stored_in_body(item, scenario_name) for item in body]
+        elif isinstance(body, str):
+            return ApiE2ETestsManager.substitute_stored(body, scenario_name)
+        else:
+            return body
+
     @staticmethod
     def store_value(key, value, scenario_name):
         namespaced_key = f"{scenario_name}.{key}"
@@ -275,7 +383,7 @@ class ApiE2ETestsManager:
 
         if not result:
             raise AssertionError(
-                f"Assertion failed: {expr}  →  evaluated as {left_val} {matched_op} {right_val}"
+                f"Assertion failed: {expr}  ->  evaluated as {left_val} {matched_op} {right_val}"
             )
         return True
 
@@ -286,67 +394,103 @@ class ApiE2ETestsManager:
         step_metrics = []
 
         print(f"Running test: {spec.get('name', scenario_name)}")
+        print(f"Base URL: {base_url}")
         print("=" * 60)
         # use a session for connection pooling and to set a default timeout
         session = requests.Session()
         for step in steps:
-            try:
-                step_start = time.time()
-                print(f"Step: {step['name']}")
-                url = base_url + ApiE2ETestsManager.substitute_stored(step['endpoint'], scenario_name)
-                method = step['method'].upper()
+            # Get retry configuration
+            retry_config = step.get("retry", {})
+            max_attempts = retry_config.get("attempts", 1)
+            delay_seconds = retry_config.get("delay_seconds", 0)
 
-                request_headers = {}
-                if "request_headers" in step:
-                    for header in step["request_headers"]:
-                        for header_key, header_value in header.items():
-                            if isinstance(header_value, str):
-                                header_value = ApiE2ETestsManager.substitute_stored(header_value, scenario_name)
-                            request_headers[header_key] = header_value
-
-                body = step.get("body")
-                expect = step.get("expect", {})
-
-                resp = session.request(method, url, json=body, headers=request_headers, timeout=ApiE2ETestsManager.DEFAULT_TIMEOUT)
-                print(f" -> {method} {url} -> {resp.status_code}")
-
-                expected_status = expect.get("status")
-                if expected_status and resp.status_code != expected_status:
-                    raise AssertionError(f"Expected {expected_status}, got {resp.status_code}")
+            last_error = None
+            step_start = time.time()
 
+            for attempt in range(max_attempts):
                 try:
-                    resp_json = resp.json()
-                except Exception:
-                    raise AssertionError("Response is not valid JSON")
-
-                if "body" in expect:
-                    if is_verbose:
-                        print(f"Response body: {resp_json}")
-                    ApiE2ETestsManager.validate_structure(resp_json, expect["body"])
-
-                if "save" in step:
-                    for key, path_expr in step["save"].items():
-                        rendered = ApiE2ETestsManager.render_template(path_expr, {"body": resp_json})
-                        ApiE2ETestsManager.store_value(key, rendered, scenario_name)
-
-                if "assertions" in step:
-                    for expr in step["assertions"]:
-                        rendered = ApiE2ETestsManager.render_template(expr, {"body": resp_json}, add_quotes=True)
-                        ApiE2ETestsManager.try_eval(rendered, expr)
-
-                elapsed = time.time() - step_start
-                step_metrics.append({"name": step["name"], "time": elapsed, "result": "PASS"})
-                print(f"[OK  ] Step passed in {elapsed:.2f}s\n")
-            except Exception as e:
+                    if attempt > 0:
+                        print(f"   Retry attempt {attempt + 1}/{max_attempts} after {delay_seconds}s delay...")
+                        time.sleep(delay_seconds)
+
+                    if attempt == 0:
+                        print(f"Step: {step['name']}")
+
+                    url = base_url + ApiE2ETestsManager.substitute_stored(step['endpoint'], scenario_name)
+                    method = step['method'].upper()
+
+                    request_headers = {}
+                    if "request_headers" in step:
+                        for header in step["request_headers"]:
+                            for header_key, header_value in header.items():
+                                if isinstance(header_value, str):
+                                    header_value = ApiE2ETestsManager.substitute_stored(header_value, scenario_name)
+                                request_headers[header_key] = header_value
+
+                    body = step.get("body")
+                    if body is not None:
+                        body = ApiE2ETestsManager.substitute_stored_in_body(body, scenario_name)
+                    expect = step.get("expect", {})
+
+                    resp = session.request(method, url, json=body, headers=request_headers, timeout=ApiE2ETestsManager.DEFAULT_TIMEOUT)
+                    print(f" -> {method} {url} -> {resp.status_code}")
+
+                    expected_status = expect.get("status")
+                    if expected_status and resp.status_code != expected_status:
+                        raise AssertionError(f"Expected {expected_status}, got {resp.status_code}")
+
+                    try:
+                        resp_json = resp.json()
+                    except Exception:
+                        raise AssertionError("Response is not valid JSON")
+
+                    if "body" in expect:
+                        if is_verbose:
+                            print(f"Response body: {resp_json}")
+                        ApiE2ETestsManager.validate_structure(resp_json, expect["body"])
+
+                    if "assertions" in step:
+                        for expr in step["assertions"]:
+                            try:
+                                rendered = ApiE2ETestsManager.render_template(expr, {"body": resp_json}, add_quotes=True)
+                                ApiE2ETestsManager.try_eval(rendered, expr)
+                            except Exception as e:
+                                raise AssertionError(f"Assertion failed for expression\n    -->'{expr}'\n    -->{str(e)}")
+
+                    if "save" in step:
+                        for key, path_expr in step["save"].items():
+                            try:
+                                rendered = ApiE2ETestsManager.render_template(path_expr, {"body": resp_json})
+                                ApiE2ETestsManager.store_value(key, rendered, scenario_name)
+                            except Exception as e:
+                                raise AssertionError(f"Failed to render save path\n    -->'{path_expr}'\n    -->{str(e)}")
+
+                    elapsed = time.time() - step_start
+                    step_metrics.append({"name": step["name"], "time": elapsed, "result": "PASS"})
+                    if attempt > 0:
+                        print(f"[OK  ] Step passed on retry attempt {attempt + 1} in {elapsed:.2f}s\n")
+                    else:
+                        print(f"[OK  ] Step passed in {elapsed:.2f}s\n")
+                    last_error = None
+                    break  # Success, exit retry loop
+
+                except Exception as e:
+                    last_error = e
+                    if attempt < max_attempts - 1:
+                        print(f"[RETRY] Attempt {attempt + 1} failed: {str(e)}")
+                    # Continue to next attempt
+
+            # Check if all attempts failed
+            if last_error is not None:
                 failed_elapsed = time.time() - step_start
-                step_metrics.append({"name": step["name"], "time": failed_elapsed, "result": "FAIL", "error": str(e)})
-                print(f"[FAIL] Step failed in {failed_elapsed:.2f}s error: {str(e)}\n")
+                step_metrics.append({"name": step["name"], "time": failed_elapsed, "result": "FAIL", "error": str(last_error)})
+                print(f"[FAIL] Step failed after {max_attempts} attempt(s) in {failed_elapsed:.2f}s\n       Error: {str(last_error)}\n")
                 break
         print("=" * 60)
         return step_metrics
 
     @staticmethod
-    def print_summary(total_time):
+    def print_summary(total_time, all_tests_passed):
         print("\n[SUMMARY] TEST RESULTS")
         print("=" * 80)
 
@@ -382,3 +526,8 @@ class ApiE2ETestsManager:
 
         print("=" * 80)
         print(f"Total Execution Time: {total_time:.2f}s\n")
+
+        if all_tests_passed:
+            print("ALL TESTS PASSED")
+        else:
+            print("SOME TESTS FAILED")

{sefrone_api_e2e-1.0.1.dist-info → sefrone_api_e2e-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sefrone-api-e2e
-Version: 1.0.1
+Version: 1.0.3
 Summary: A Python package to provide e2e testing helpers for sefrone API projects
 Home-page: https://bitbucket.org/sefrone/sefrone_pypi
 Author: Sefrone

sefrone_api_e2e-1.0.3.dist-info/RECORD

@@ -0,0 +1,6 @@
+sefrone_api_e2e/__init__.py,sha256=NNUHigTCBkjdwCfQXVEA7urxF1-A8HF1_IuWJ8LuO-k,91
+sefrone_api_e2e/api_e2e_manager.py,sha256=vAA0-H3dVKIUptyxXbYaiZP_9PYu58z9LCj_vi53vwY,23584
+sefrone_api_e2e-1.0.3.dist-info/METADATA,sha256=cHEc8npSLW23SM7hxt0GYKY6q8vHCghpPv7oUB-IhUQ,721
+sefrone_api_e2e-1.0.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+sefrone_api_e2e-1.0.3.dist-info/top_level.txt,sha256=19WO3CsUWUiGtZBotT587N-tkxxjctKOPDEHWpHpS8M,16
+sefrone_api_e2e-1.0.3.dist-info/RECORD,,

sefrone_api_e2e-1.0.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-sefrone_api_e2e/__init__.py,sha256=NNUHigTCBkjdwCfQXVEA7urxF1-A8HF1_IuWJ8LuO-k,91
-sefrone_api_e2e/api_e2e_manager.py,sha256=3oA9JqDQR9L_Fj5YRgeXpPcFxl28FRLNN_hdjB1017E,16464
-sefrone_api_e2e-1.0.1.dist-info/METADATA,sha256=-qjd_wb2tI9jnSQKe7rt0fIMe4Is7-012z8SGutmlCw,721
-sefrone_api_e2e-1.0.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-sefrone_api_e2e-1.0.1.dist-info/top_level.txt,sha256=19WO3CsUWUiGtZBotT587N-tkxxjctKOPDEHWpHpS8M,16
-sefrone_api_e2e-1.0.1.dist-info/RECORD,,