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

sefrone_api_e2e/api_e2e_manager.py

@@ -3,31 +3,130 @@ import requests
 import re
 import os
 import datetime
+import time
+from pathlib import Path
+from typing import Any, Dict, List
 
 class ApiE2ETestsManager:
+    # Precompiled patterns and defaults
+    VAR_PATTERN = re.compile(r"\$var\(([A-Za-z0-9_]+)\)")
+    STORED_PATTERN = re.compile(r"\{\$stored\.([a-zA-Z0-9_.]+)\}")
+    TEMPLATE_PATTERN = re.compile(r"\{\{\s*([^}]+?)\s*\}\}")
+    DEFAULT_TIMEOUT = 10  # seconds for HTTP requests
+
+    # Mutable state (reset at run start)
+    global_store: Dict[str, Any] = {}
+    scenario_results: List[Dict[str, Any]] = []  # holds timing + status info for all scenarios
+
     @staticmethod
-    def run_all_tests(folder_path, is_verbose=False):
+    def run_all_tests(folder_path, env_file_path, is_verbose=False):
         print("\nRunning API E2E tests...")
-        for filename in os.listdir(folder_path):
-            if filename.endswith(".yaml") or filename.endswith(".yml"):
-                file_path = os.path.join(folder_path, filename)
+
+        # Reset shared state to avoid leakage between runs
+        ApiE2ETestsManager.global_store = {}
+        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"]) 
+        total_start = time.time()
+
+        for filename in scenario_files:
+            yaml_file_path = os.path.join(folder_path, filename)
+            scenario_name = os.path.splitext(filename)[0]
+
+            try:
                 print(f"\n--- Running scenario: {filename} ---")
-                ApiE2ETestsManager.run_yaml_test(file_path, is_verbose)
+                spec = ApiE2ETestsManager.parse_and_load_yaml(yaml_file_path, env_file_path)
+                start_time = time.time()
+                step_metrics = ApiE2ETestsManager.run_yaml_test(spec, scenario_name, is_verbose)
+                elapsed = time.time() - start_time
+
+                if all(step["result"] == "PASS" for step in step_metrics):
+                    ApiE2ETestsManager.scenario_results.append({
+                        "scenario": scenario_name,
+                        "status": "[PASS]",
+                        "steps": step_metrics,
+                        "total_time": elapsed
+                    })
+                else:
+                    ApiE2ETestsManager.scenario_results.append({
+                        "scenario": scenario_name,
+                        "status": "[FAIL]",
+                        "steps": step_metrics,
+                        "total_time": elapsed
+                    })
+                    # mark remaining scenarios as skipped
+                    remaining = scenario_files[scenario_files.index(filename)+1:]
+                    for skipped_file in remaining:
+                        skipped_name = os.path.splitext(skipped_file)[0]
+                        ApiE2ETestsManager.scenario_results.append({
+                            "scenario": skipped_name,
+                            "status": "[SKIP]",
+                            "steps": [],
+                            "total_time": 0
+                        })
+                    break
+
+            except AssertionError:
+                # mark the failed one
+                failed_elapsed = time.time() - start_time if 'start_time' in locals() else 0
+                ApiE2ETestsManager.scenario_results.append({
+                    "scenario": scenario_name,
+                    "status": "[FAIL]",
+                    "steps": step_metrics if 'step_metrics' in locals() else [],
+                    "total_time": failed_elapsed
+                })
+                # mark remaining scenarios as skipped
+                remaining = scenario_files[scenario_files.index(filename)+1:]
+                for skipped_file in remaining:
+                    skipped_name = os.path.splitext(skipped_file)[0]
+                    ApiE2ETestsManager.scenario_results.append({
+                        "scenario": skipped_name,
+                        "status": "[SKIP]",
+                        "steps": [],
+                        "total_time": 0
+                    })
+                break  # stop all further execution
+
+        total_elapsed = time.time() - total_start
         print("\nAPI E2E tests completed.")
+        ApiE2ETestsManager.print_summary(total_elapsed)
 
     @staticmethod
-    def load_yaml(path):
-        with open(path, "r", encoding="utf-8") as f:
-            return yaml.safe_load(f)
+    def read_env_value_from_file(env_file_path, env_var):
+        try:
+            with open(env_file_path, 'r', encoding='utf-8') as file:
+                for raw in file:
+                    line = raw.strip()
+                    if not line or line.startswith('#'):
+                        continue
+                    if line.startswith(f'{env_var}='):
+                        return line[len(f'{env_var}='):].strip()
+        except FileNotFoundError:
+            print(f"[WARN] Environment file not found: {env_file_path}")
+            return ""
+        print(f"[WARN] Environment variable '{env_var}' not found in {env_file_path}.")
+        return ""
+
+    @staticmethod
+    def parse_and_load_yaml(yaml_file_path, env_file_path):
+        with open(yaml_file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        def replacer(match):
+            key = match.group(1)
+            return ApiE2ETestsManager.read_env_value_from_file(env_file_path, key)
+
+        resolved_content = ApiE2ETestsManager.VAR_PATTERN.sub(replacer, content)
+        return yaml.safe_load(resolved_content)
 
     @staticmethod
     def check_type(value, expected_type):
-        """Check if value matches expected type keyword."""
         type_map = {
             "string": str,
             "number": (int, float),
             "boolean": bool,
-            "datetime": str  # basic check; could extend with parsing
+            "datetime": str
         }
         if expected_type not in type_map:
             raise ValueError(f"Unknown type in YAML: {expected_type}")
@@ -46,7 +145,6 @@ class ApiE2ETestsManager:
 
     @staticmethod
     def validate_structure(data, expected):
-        """Recursively validate structure & type expectations."""
         if isinstance(expected, dict):
             if not isinstance(data, dict):
                 raise AssertionError(f"Expected dict but got {type(data)}")
@@ -60,7 +158,7 @@ class ApiE2ETestsManager:
             if len(expected) > 0:
                 for item in data:
                     ApiE2ETestsManager.validate_structure(item, expected[0])
-        elif isinstance(expected, str):  # type keyword
+        elif isinstance(expected, str):
             if not ApiE2ETestsManager.check_type(data, expected):
                 raise AssertionError(f"Expected {expected}, got {data} ({type(data)})")
         else:
@@ -80,89 +178,207 @@ class ApiE2ETestsManager:
 
         def replacer(match):
             expr = match.group(1).strip()
-            for root_key in context:
-                if expr.startswith(root_key + "."):
-                    val = resolve_path(expr, context)
-                    if isinstance(val, str):
-                        return repr(val) if add_quotes else str(val) # adds quotes safely
-                    elif val is True:
-                        return "True"
-                    elif val is False:
-                        return "False"
-                    elif val is None:
-                        return "None"
-                    else:
-                        return str(val)
-            raise KeyError(f"Unknown variable: {expr}")
-
-        return re.sub(r"\{\{\s*([^}]+?)\s*\}\}", replacer, template_str)
+            val = resolve_path(expr, context)
+            if isinstance(val, str):
+                return repr(val) if add_quotes else str(val)
+            elif val is True:
+                return "True"
+            elif val is False:
+                return "False"
+            elif val is None:
+                return "None"
+            else:
+                return str(val)
+
+        return ApiE2ETestsManager.TEMPLATE_PATTERN.sub(replacer, template_str)
 
     @staticmethod
-    def substitute_stored(endpoint, stored):
-        """Substitute {$stored.key} placeholders."""
+    def substitute_stored(expr, scenario_name):
         def repl(match):
-            key = match.group(1)
-            return str(stored.get(key, f"<MISSING:{key}>"))
-        return re.sub(r"\{\$stored\.([a-zA-Z0-9_]+)\}", repl, endpoint)
+            key = match.group(1).strip()
+            parts = key.split(".")
+            if len(parts) == 1:
+                subkey = parts[0]
+                return str(ApiE2ETestsManager.global_store.get(f"{scenario_name}.{subkey}", f"<MISSING:{subkey}>"))
+            elif len(parts) == 2:
+                scen, subkey = parts
+                return str(ApiE2ETestsManager.global_store.get(f"{scen}.{subkey}", f"<MISSING:{key}>"))
+            else:
+                raise ValueError(f"Invalid stored key reference: {key} (Too many dots)")
+
+        return ApiE2ETestsManager.STORED_PATTERN.sub(repl, expr)
+
+    @staticmethod
+    def store_value(key, value, scenario_name):
+        namespaced_key = f"{scenario_name}.{key}"
+        ApiE2ETestsManager.global_store[namespaced_key] = value
+        print(f"   Saved: {namespaced_key} = {value}")
+
+    @staticmethod
+    def try_eval(rendered, expr):
+    # Basic supported operators
+        operators = [">=", "<=", ">", "<", "==", "!=", "in", "not in", "include"]
+
+        matched_op = None
+        for op in operators:
+            if f" {op} " in rendered:
+                matched_op = op
+                left, right = [part.strip() for part in rendered.split(f" {op} ", 1)]
+                break
+
+        if not matched_op:
+            raise AssertionError(f"Unsupported assertion format: '{expr}'")
+
+        # Try to evaluate left and right sides
+        def try_eval_part(value):
+            # Try to interpret as int/float/bool/None/string
+            if re.match(r"^-?\d+\.\d+$", value):
+                return float(value)
+            elif re.match(r"^-?\d+$", value):
+                return int(value)
+            elif value.lower() == "true":
+                return True
+            elif value.lower() == "false":
+                return False
+            elif value.lower() == "none":
+                return None
+            elif value.startswith('"') and value.endswith('"'):
+                return value.strip('"')
+            elif value.startswith("'") and value.endswith("'"):
+                return value.strip("'")
+            else:
+                return value  # treat as literal string
+
+        left_val = try_eval_part(left)
+        right_val = try_eval_part(right)
+
+        # Comparison logic
+        result = False
+        if matched_op == "==":
+            result = left_val == right_val
+        elif matched_op == "!=":
+            result = left_val != right_val
+        elif matched_op == ">":
+            result = left_val > right_val
+        elif matched_op == "<":
+            result = left_val < right_val
+        elif matched_op == ">=":
+            result = left_val >= right_val
+        elif matched_op == "<=":
+            result = left_val <= right_val
+        elif matched_op == "in":
+            result = left_val in right_val
+        elif matched_op == "not in":
+            result = left_val not in right_val
+        elif matched_op == "include":
+            result = right_val in left_val
+
+        if not result:
+            raise AssertionError(
+                f"Assertion failed: {expr}  →  evaluated as {left_val} {matched_op} {right_val}"
+            )
+        return True
 
     @staticmethod
-    def run_yaml_test(path, is_verbose=False):
-        spec = ApiE2ETestsManager.load_yaml(path)
+    def run_yaml_test(spec, scenario_name, is_verbose=False):
         base_url = spec.get("base_url", "")
         steps = spec.get("steps", [])
-        stored = {}
+        step_metrics = []
 
-        print(f"Running test: {spec['name']}")
+        print(f"Running test: {spec.get('name', scenario_name)}")
         print("=" * 60)
-
+        # use a session for connection pooling and to set a default timeout
+        session = requests.Session()
         for step in steps:
-            print(f"Step: {step['name']}")
-            url = base_url + ApiE2ETestsManager.substitute_stored(step['endpoint'], stored)
-            method = step['method'].upper()
-            body = step.get("body")
-            expect = step.get("expect", {})
-
-            # Make HTTP request
-            resp = requests.request(method, url, json=body)
-            print(f" → {method} {url} -> {resp.status_code}")
-
-            # Validate status code
-            expected_status = expect.get("status")
-            if expected_status and resp.status_code != expected_status:
-                if is_verbose:
-                    print(f"Response body: {resp.text}")
-                raise AssertionError(f"Expected {expected_status}, got {resp.status_code}")
-
-            # Parse response JSON
             try:
-                resp_json = resp.json()
-            except Exception:
-                raise AssertionError("Response is not valid JSON")
-
-            # Validate body structure
-            if "body" in expect:
-                if is_verbose:
-                    print(f"Response body: {resp_json}")
-                ApiE2ETestsManager.validate_structure(resp_json, expect["body"])
-
-            # Save variables
-            if "save" in step:
-                for key, path_expr in step["save"].items():
-                    rendered = ApiE2ETestsManager.render_template(path_expr, {"body": resp_json, "stored": stored})
-                    stored[key] = rendered
-                    print(f"   Saved: {key} = {rendered}")
-
-            # Assertions
-            if "assertions" in step:
-                for expr in step["assertions"]:
-                    rendered = ApiE2ETestsManager.render_template(expr, {"body": resp_json, "stored": stored}, add_quotes=True)
-                    try:
-                        if not eval(rendered):
-                            raise AssertionError(f"Assertion failed: {expr}, rendered as '{rendered}'")
-                    except Exception as e:
-                        raise AssertionError(f"Assertion error in '{expr}', rendered as '{rendered}': {e}")
-
-            print(" ✅ Step passed.\n")
+                step_start = time.time()
+                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")
+                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 "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:
+                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")
+                break
         print("=" * 60)
-        print("🎉 All steps passed successfully!")
+        return step_metrics
+
+    @staticmethod
+    def print_summary(total_time):
+        print("\n[SUMMARY] TEST RESULTS")
+        print("=" * 80)
+
+        headers = ["Scenario", "Status", "Time (s)", "Steps"]
+        col_widths = [30, 7, 8, 50]
+
+        header_line = f"{headers[0]:<{col_widths[0]}} | {headers[1]:<{col_widths[1]}} | {headers[2]:<{col_widths[2]}} | {headers[3]}"
+        print(header_line)
+        print("-" * len(header_line))
+
+        for result in ApiE2ETestsManager.scenario_results:
+            print(f"{result['scenario']:<{col_widths[0]}} | "
+                  f"{result['status']:<{col_widths[1]}} | "
+                  f"{result['total_time']:<{col_widths[2]}.2f} | ")
+
+            if result["steps"]:
+                for step in result["steps"]:
+                    parsed = f"[{step['result']}] {step['name']} ({step['time']:.2f}s)"
+                    print(f"{'':<{col_widths[0]}} | "
+                          f"{'':<{col_widths[1]}} | "
+                          f"{'':<{col_widths[2]}} | "
+                          f"{parsed:<{col_widths[3]}}")
+                    if step['result'] == "FAIL" and 'error' in step:
+                        print(f"{'':<{col_widths[0]}} | "
+                              f"{'':<{col_widths[1]}} | "
+                              f"{'':<{col_widths[2]}} | "
+                              f"===> {step['error']}")
+            else:
+                print(f"{'':<{col_widths[0]}} | "
+                      f"{'':<{col_widths[1]}} | "
+                      f"{'':<{col_widths[2]}} | "
+                      f"{'(no steps run)':<{col_widths[3]}}")
+
+        print("=" * 80)
+        print(f"Total Execution Time: {total_time:.2f}s\n")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sefrone-api-e2e
-Version: 1.0.0
+Version: 1.0.1
 Summary: A Python package to provide e2e testing helpers for sefrone API projects
 Home-page: https://bitbucket.org/sefrone/sefrone_pypi
 Author: Sefrone
@@ -13,6 +13,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: PyYAML>=6.0.1
+Requires-Dist: requests
 
 This is not a usable Python package, but the name is reserved by SARL Sefrone.
 

sefrone_api_e2e-1.0.1.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=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,,

sefrone_api_e2e-1.0.0.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=3LDA-kIZLyhVTvxZFE4huJdVTKQfsZmIdiTpeGwoVPs,6984
-sefrone_api_e2e-1.0.0.dist-info/METADATA,sha256=k4CtrauVJStV0vCz3tb5hkNM552nz5KyMro1wG7AK4U,696
-sefrone_api_e2e-1.0.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-sefrone_api_e2e-1.0.0.dist-info/top_level.txt,sha256=19WO3CsUWUiGtZBotT587N-tkxxjctKOPDEHWpHpS8M,16
-sefrone_api_e2e-1.0.0.dist-info/RECORD,,