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

sefrone_api_e2e/__init__.py

@@ -0,0 +1,5 @@
+from .api_e2e_manager import ApiE2ETestsManager
+
+__all__ = [
+    "ApiE2ETestsManager"
+]

sefrone_api_e2e/api_e2e_manager.py

@@ -0,0 +1,168 @@
+import yaml
+import requests
+import re
+import os
+import datetime
+
+class ApiE2ETestsManager:
+    @staticmethod
+    def run_all_tests(folder_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)
+                print(f"\n--- Running scenario: {filename} ---")
+                ApiE2ETestsManager.run_yaml_test(file_path, is_verbose)
+        print("\nAPI E2E tests completed.")
+
+    @staticmethod
+    def load_yaml(path):
+        with open(path, "r", encoding="utf-8") as f:
+            return yaml.safe_load(f)
+
+    @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
+        }
+        if expected_type not in type_map:
+            raise ValueError(f"Unknown type in YAML: {expected_type}")
+        if expected_type == "datetime":
+            try:
+                datetime.datetime.fromisoformat(value)
+                return True
+            except Exception:
+                try:
+                    if re.match(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{1,6}$", value):
+                        datetime.datetime.strptime(value, "%Y-%m-%dT%H:%M:%S.%f")
+                    return True
+                except Exception:
+                    return False
+        return isinstance(value, type_map[expected_type])
+
+    @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)}")
+            for k, v in expected.items():
+                if k not in data:
+                    raise AssertionError(f"Missing key: {k} (Data keys: {list(data.keys())})")
+                ApiE2ETestsManager.validate_structure(data[k], v)
+        elif isinstance(expected, list):
+            if not isinstance(data, list):
+                raise AssertionError(f"Expected list but got {type(data)}")
+            if len(expected) > 0:
+                for item in data:
+                    ApiE2ETestsManager.validate_structure(item, expected[0])
+        elif isinstance(expected, str):  # type keyword
+            if not ApiE2ETestsManager.check_type(data, expected):
+                raise AssertionError(f"Expected {expected}, got {data} ({type(data)})")
+        else:
+            raise ValueError(f"Invalid expected type: {expected}")
+
+    @staticmethod
+    def render_template(template_str, context, add_quotes=False):
+        def resolve_path(expr, ctx):
+            parts = expr.split(".")
+            val = ctx
+            for p in parts:
+                if isinstance(val, dict) and p in val:
+                    val = val[p]
+                else:
+                    raise KeyError(f"Cannot resolve '{expr}' in context: {p} not found")
+            return val
+
+        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)
+
+    @staticmethod
+    def substitute_stored(endpoint, stored):
+        """Substitute {$stored.key} placeholders."""
+        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)
+
+    @staticmethod
+    def run_yaml_test(path, is_verbose=False):
+        spec = ApiE2ETestsManager.load_yaml(path)
+        base_url = spec.get("base_url", "")
+        steps = spec.get("steps", [])
+        stored = {}
+
+        print(f"Running test: {spec['name']}")
+        print("=" * 60)
+
+        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")
+
+        print("=" * 60)
+        print("🎉 All steps passed successfully!")

sefrone_api_e2e-1.0.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: sefrone-api-e2e
+Version: 1.0.0
+Summary: A Python package to provide e2e testing helpers for sefrone API projects
+Home-page: https://bitbucket.org/sefrone/sefrone_pypi
+Author: Sefrone
+Author-email: contact@sefrone.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML>=6.0.1
+
+This is not a usable Python package, but the name is reserved by SARL Sefrone.
+
+You can find other packages published by Sefrone at pypi.org/user/gnasreddine
+

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

sefrone_api_e2e-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sefrone_api_e2e-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sefrone_api_e2e