sefrone-api-e2e 1.2.1__tar.gz → 1.2.3__tar.gz

{sefrone_api_e2e-1.2.1 → sefrone_api_e2e-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sefrone_api_e2e
-Version: 1.2.1
+Version: 1.2.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.2.1 → sefrone_api_e2e-1.2.3}/sefrone_api_e2e/api_e2e_manager.py

@@ -396,6 +396,68 @@ class ApiE2ETestsManager:
                                 i = close_paren + 1
                                 if i < len(expr) and expr[i] == ".":
                                     i += 1
+                            elif prop == "where":
+                                close_paren = expr.find(")", end_pos)
+                                if close_paren == -1:
+                                    raise ValueError(f"Unclosed parenthesis in: {expr}")
+                                condition_str = expr[end_pos + 1:close_paren].strip()
+                                if not isinstance(val, list):
+                                    raise KeyError(f"Cannot call where() on {type(val).__name__}")
+                                cond_operators = ["not in", ">=", "<=", ">", "<", "==", "!=", "in", "include"]
+                                cond_op = None
+                                cond_left = cond_right = ""
+                                for cop in cond_operators:
+                                    if f" {cop} " in condition_str:
+                                        cond_op = cop
+                                        cond_left, cond_right = [p.strip() for p in condition_str.split(f" {cop} ", 1)]
+                                        break
+                                if not cond_op:
+                                    raise ValueError(f"Unsupported where() condition: '{condition_str}'")
+                                def _parse_where_literal(s):
+                                    if (s.startswith("'") and s.endswith("'")) or (s.startswith('"') and s.endswith('"')):
+                                        return s[1:-1]
+                                    elif re.match(r'^-?\d+\.\d+$', s):
+                                        return float(s)
+                                    elif re.match(r'^-?\d+$', s):
+                                        return int(s)
+                                    elif s.lower() == 'true':
+                                        return True
+                                    elif s.lower() == 'false':
+                                        return False
+                                    elif s.lower() == 'none':
+                                        return None
+                                    return s
+                                right_literal = _parse_where_literal(cond_right)
+                                filtered = []
+                                for item in val:
+                                    if isinstance(item, dict) and cond_left in item:
+                                        item_val = item[cond_left]
+                                        match = False
+                                        if cond_op == "==" :
+                                            match = item_val == right_literal
+                                        elif cond_op == "!=":
+                                            match = item_val != right_literal
+                                        elif cond_op == ">":
+                                            match = item_val > right_literal
+                                        elif cond_op == "<":
+                                            match = item_val < right_literal
+                                        elif cond_op == ">=":
+                                            match = item_val >= right_literal
+                                        elif cond_op == "<=":
+                                            match = item_val <= right_literal
+                                        elif cond_op == "in":
+                                            match = item_val in right_literal
+                                        elif cond_op == "not in":
+                                            match = item_val not in right_literal
+                                        elif cond_op == "include":
+                                            match = right_literal in item_val
+                                        if match:
+                                            filtered.append(item)
+                                val = filtered
+                                current_path += f".where({condition_str})"
+                                i = close_paren + 1
+                                if i < len(expr) and expr[i] == ".":
+                                    i += 1
                             else:
                                 raise ValueError(f"Unsupported function '{prop}()': {expr}")
                         elif isinstance(val, dict) and prop in val:

{sefrone_api_e2e-1.2.1 → sefrone_api_e2e-1.2.3}/sefrone_api_e2e/runner_rest_api.py

@@ -1,5 +1,6 @@
 import hashlib
 import os
+import random
 import secrets
 import time
 from typing import Any
@@ -66,20 +67,63 @@ class RestApiRunner(StepRunner):
     def _handle_randomize(self, step: dict, ctx: RunContext) -> StepResult:
         spec = step["randomize"]
         if isinstance(spec, dict):
-            for key, length in spec.items():
-                if not isinstance(length, int) or length <= 0:
-                    length = 8
-                ctx.store_value(key, self._random_string(length))
+            for key, value in spec.items():
+                ctx.store_value(key, self._generate_random_value(value))
         elif isinstance(spec, list):
             for key in spec:
                 ctx.store_value(key, self._random_string(8))
         return StepResult.passed()
 
+    def _generate_random_value(self, spec) -> str:
+        """
+        Generate a random value from a spec:
+
+        - ``int``  (e.g. ``8``) → random hex string of that length  (backward-compat)
+        - ``{type: string, length: N}`` → random hex string of length N
+        - ``{type: string, length: N, chars: digits}`` → digits-only string of length N
+        - ``{type: string, length: N, chars: hex}`` → hex string of length N (default)
+        - ``{type: number, min: N, max: M}`` → random integer in [min, max] (inclusive)
+        - ``{type: float, min: N, max: M}`` → random float in [min, max]
+        """
+        if isinstance(spec, int):
+            length = spec if spec > 0 else 8
+            return self._random_string(length)
+
+        if isinstance(spec, dict):
+            kind = str(spec.get("type", "string")).lower()
+
+            if kind == "string":
+                length = int(spec.get("length", 8))
+                if length <= 0:
+                    length = 8
+                chars = str(spec.get("chars", "hex")).lower()
+                if chars == "digits":
+                    return self._random_digits(length)
+                return self._random_string(length)
+
+            if kind == "number":
+                min_val = int(spec.get("min", 0))
+                max_val = int(spec.get("max", 9999))
+                return str(random.randint(min_val, max_val))
+
+            if kind == "float":
+                min_val = float(spec.get("min", 0.0))
+                max_val = float(spec.get("max", 1.0))
+                precision = int(spec.get("precision", 2))
+                return str(round(random.uniform(min_val, max_val), precision))
+
+        # fallback
+        return self._random_string(8)
+
     @staticmethod
     def _random_string(length: int = 8) -> str:
         n_bytes = (length + 1) // 2
         return secrets.token_hex(n_bytes)[:length]
 
+    @staticmethod
+    def _random_digits(length: int = 8) -> str:
+        return "".join(str(random.randint(0, 9)) for _ in range(length))
+
     # ------------------------------------------------------------------ #
     #  HTTP
     # ------------------------------------------------------------------ #

{sefrone_api_e2e-1.2.1 → sefrone_api_e2e-1.2.3}/sefrone_api_e2e.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sefrone_api_e2e
-Version: 1.2.1
+Version: 1.2.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.2.1 → sefrone_api_e2e-1.2.3}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="sefrone_api_e2e",
-    version="1.2.1",
+    version="1.2.3",
     author="Sefrone",
     author_email="contact@sefrone.com",
     description="A Python package to provide e2e testing helpers for sefrone API projects",