sefrone-api-e2e 1.0.2__tar.gz → 1.0.4__tar.gz

{sefrone_api_e2e-1.0.2 → sefrone_api_e2e-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sefrone_api_e2e
-Version: 1.0.2
+Version: 1.0.4
 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.4/sefrone_api_e2e/__init__.py

@@ -0,0 +1,9 @@
+from .api_e2e_manager import ApiE2ETestsManager
+from .email_mock_server import EmailMockServer
+from .json_mock_server import JsonMockServer
+
+__all__ = [
+    "ApiE2ETestsManager",
+    "EmailMockServer",
+    "JsonMockServer"
+]

{sefrone_api_e2e-1.0.2 → sefrone_api_e2e-1.0.4}/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,114 @@ 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
+
+                    request_query_params = {}
+                    if "request_query_params" in step:
+                        params = step["request_query_params"]
+                        if isinstance(params, dict):
+                            for param_key, param_value in params.items():
+                                if isinstance(param_value, str):
+                                    param_value = ApiE2ETestsManager.substitute_stored(param_value, scenario_name)
+                                request_query_params[param_key] = param_value
+                        else:
+                            raise ValueError(f"query_params must be a dictionary, got {type(params)}")
+
+                    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, params=request_query_params, 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 +537,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.4/sefrone_api_e2e/email_mock_server.py

@@ -0,0 +1,480 @@
+import threading
+import json
+import socket
+import email
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+
+class EmailMockServer:
+    """
+    Comprehensive mock email server that supports SMTP, IMAP, and HTTP protocols.
+    
+    Features:
+    - SMTP server for receiving emails (standard protocol)
+    - IMAP server for checking emails (standard protocol)
+    - HTTP API for test automation and verification
+    - Query captured emails via GET /emails
+    - Clear emails via DELETE /emails
+    """
+    
+    def __init__(self, host: str = "localhost", http_port: int = 8025, smtp_port: int = 1025, imap_port: int = 1143):
+        self.host = host
+        self.http_port = http_port
+        self.smtp_port = smtp_port
+        self.imap_port = imap_port
+        self.emails: List[Dict[str, Any]] = []
+        self._http_server: Optional[HTTPServer] = None
+        self._smtp_thread: Optional[threading.Thread] = None
+        self._imap_thread: Optional[threading.Thread] = None
+        self._http_thread: Optional[threading.Thread] = None
+        self._running = False
+        self._smtp_socket: Optional[socket.socket] = None
+        self._imap_socket: Optional[socket.socket] = None
+        self._next_uid = 1
+        
+    def start(self):
+        """Start all email server protocols in background threads."""
+        if self._running:
+            print(f"[EmailMockServer] Already running")
+            return
+            
+        self._running = True
+        
+        # Start HTTP server
+        handler = self._create_http_handler()
+        self._http_server = HTTPServer((self.host, self.http_port), handler)
+        self._http_thread = threading.Thread(target=self._http_server.serve_forever, daemon=True)
+        self._http_thread.start()
+        print(f"[EmailMockServer] HTTP API started on http://{self.host}:{self.http_port}")
+        
+        # Start SMTP server
+        self._smtp_thread = threading.Thread(target=self._run_smtp_server, daemon=True)
+        self._smtp_thread.start()
+        print(f"[EmailMockServer] SMTP server started on {self.host}:{self.smtp_port}")
+        
+        # Start IMAP server
+        self._imap_thread = threading.Thread(target=self._run_imap_server, daemon=True)
+        self._imap_thread.start()
+        print(f"[EmailMockServer] IMAP server started on {self.host}:{self.imap_port}")
+        
+    def stop(self):
+        """Stop all email server protocols."""
+        if not self._running:
+            return
+            
+        self._running = False
+        
+        # Stop HTTP server
+        if self._http_server:
+            self._http_server.shutdown()
+            self._http_server.server_close()
+        if self._http_thread:
+            self._http_thread.join(timeout=2)
+            
+        # Stop SMTP server
+        if self._smtp_socket:
+            try:
+                self._smtp_socket.close()
+            except:
+                pass
+        if self._smtp_thread:
+            self._smtp_thread.join(timeout=2)
+            
+        # Stop IMAP server
+        if self._imap_socket:
+            try:
+                self._imap_socket.close()
+            except:
+                pass
+        if self._imap_thread:
+            self._imap_thread.join(timeout=2)
+            
+        print(f"[EmailMockServer] Stopped all protocols")
+        
+    def clear(self):
+        """Clear all captured emails."""
+        self.emails.clear()
+        print(f"[EmailMockServer] Cleared all emails")
+        
+    def get_emails(self) -> List[Dict[str, Any]]:
+        """Get all captured emails."""
+        return self.emails.copy()
+        
+    def get_email(self, index: int) -> Optional[Dict[str, Any]]:
+        """Get a specific email by index."""
+        if 0 <= index < len(self.emails):
+            return self.emails[index]
+        return None
+        
+    def count_emails(self) -> int:
+        """Get the count of captured emails."""
+        return len(self.emails)
+        
+    def find_emails(self, **filters) -> List[Dict[str, Any]]:
+        """
+        Find emails matching the given filters.
+        
+        Example:
+            find_emails(to="user@example.com", subject="Welcome")
+        """
+        results = []
+        for email_data in self.emails:
+            match = True
+            for key, value in filters.items():
+                if key not in email_data or email_data[key] != value:
+                    match = False
+                    break
+            if match:
+                results.append(email_data)
+        return results
+    
+    def _run_smtp_server(self):
+        """Run a simple SMTP server to receive emails."""
+        self._smtp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._smtp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self._smtp_socket.bind((self.host, self.smtp_port))
+        self._smtp_socket.listen(5)
+        self._smtp_socket.settimeout(1.0)
+        
+        while self._running:
+            try:
+                client_socket, addr = self._smtp_socket.accept()
+                threading.Thread(target=self._handle_smtp_client, args=(client_socket,), daemon=True).start()
+            except socket.timeout:
+                continue
+            except Exception as e:
+                if self._running:
+                    print(f"[EmailMockServer] SMTP error: {e}")
+                break
+    
+    def _handle_smtp_client(self, client_socket: socket.socket):
+        """Handle SMTP client connection."""
+        try:
+            client_socket.sendall(b"220 Mock SMTP Server Ready\r\n")
+            
+            mail_from = None
+            rcpt_to = []
+            data_mode = False
+            email_data = []
+            
+            while True:
+                data = client_socket.recv(4096).decode('utf-8', errors='ignore')
+                if not data:
+                    break
+                
+                lines = data.strip().split('\r\n')
+                for line in lines:
+                    if not line:
+                        continue
+                    
+                    if data_mode:
+                        if line == '.':
+                            # End of email data
+                            data_mode = False
+                            email_content = '\r\n'.join(email_data)
+                            self._store_smtp_email(mail_from, rcpt_to, email_content)
+                            client_socket.sendall(b"250 OK: Message accepted\r\n")
+                            email_data = []
+                            mail_from = None
+                            rcpt_to = []
+                        else:
+                            email_data.append(line)
+                    elif line.upper().startswith('EHLO') or line.upper().startswith('HELO'):
+                        client_socket.sendall(b"250 Hello\r\n")
+                    elif line.upper().startswith('MAIL FROM:'):
+                        mail_from = line[10:].strip().strip('<>')
+                        client_socket.sendall(b"250 OK\r\n")
+                    elif line.upper().startswith('RCPT TO:'):
+                        rcpt_to.append(line[8:].strip().strip('<>'))
+                        client_socket.sendall(b"250 OK\r\n")
+                    elif line.upper() == 'DATA':
+                        data_mode = True
+                        client_socket.sendall(b"354 Start mail input; end with <CRLF>.<CRLF>\r\n")
+                    elif line.upper() == 'QUIT':
+                        client_socket.sendall(b"221 Bye\r\n")
+                        return
+                    else:
+                        client_socket.sendall(b"250 OK\r\n")
+        except Exception as e:
+            print(f"[EmailMockServer] SMTP client error: {e}")
+        finally:
+            client_socket.close()
+    
+    def _store_smtp_email(self, mail_from: str, rcpt_to: List[str], raw_content: str):
+        """Parse and store an SMTP email."""
+        try:
+            msg = email.message_from_string(raw_content)
+            
+            # Extract email details
+            subject = msg.get('Subject', '')
+            to = msg.get('To', ', '.join(rcpt_to) if rcpt_to else '')
+            from_addr = msg.get('From', mail_from or '')
+            
+            # Get body
+            body = ""
+            if msg.is_multipart():
+                for part in msg.walk():
+                    if part.get_content_type() == "text/plain":
+                        body = part.get_payload(decode=True).decode('utf-8', errors='ignore')
+                        break
+            else:
+                body = msg.get_payload(decode=True)
+                if body:
+                    body = body.decode('utf-8', errors='ignore')
+                else:
+                    body = msg.get_payload()
+            
+            email_data = {
+                "index": len(self.emails),
+                "uid": self._next_uid,
+                "to": to,
+                "from": from_addr,
+                "subject": subject,
+                "body": body,
+                "raw": raw_content,
+                "received_at": datetime.utcnow().isoformat(),
+                "flags": []
+            }
+            
+            self._next_uid += 1
+            self.emails.append(email_data)
+            
+            print(f"[EmailMockServer] SMTP captured email #{email_data['index']}: "
+                  f"from={from_addr}, to={to}, subject={subject}")
+        except Exception as e:
+            print(f"[EmailMockServer] Error parsing SMTP email: {e}")
+    
+    def _run_imap_server(self):
+        """Run a simple IMAP server to allow checking emails."""
+        self._imap_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._imap_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self._imap_socket.bind((self.host, self.imap_port))
+        self._imap_socket.listen(5)
+        self._imap_socket.settimeout(1.0)
+        
+        while self._running:
+            try:
+                client_socket, addr = self._imap_socket.accept()
+                threading.Thread(target=self._handle_imap_client, args=(client_socket,), daemon=True).start()
+            except socket.timeout:
+                continue
+            except Exception as e:
+                if self._running:
+                    print(f"[EmailMockServer] IMAP error: {e}")
+                break
+    
+    def _handle_imap_client(self, client_socket: socket.socket):
+        """Handle IMAP client connection."""
+        try:
+            client_socket.sendall(b"* OK Mock IMAP Server Ready\r\n")
+            
+            authenticated = False
+            selected_mailbox = None
+            
+            while True:
+                data = client_socket.recv(4096).decode('utf-8', errors='ignore')
+                if not data:
+                    break
+                
+                lines = data.strip().split('\r\n')
+                for line in lines:
+                    if not line:
+                        continue
+                    
+                    parts = line.split(' ', 2)
+                    if len(parts) < 2:
+                        continue
+                    
+                    tag = parts[0]
+                    command = parts[1].upper()
+                    args = parts[2] if len(parts) > 2 else ""
+                    
+                    if command == 'CAPABILITY':
+                        client_socket.sendall(b"* CAPABILITY IMAP4rev1\r\n")
+                        client_socket.sendall(f"{tag} OK CAPABILITY completed\r\n".encode())
+                    
+                    elif command == 'LOGIN':
+                        authenticated = True
+                        client_socket.sendall(f"{tag} OK LOGIN completed\r\n".encode())
+                    
+                    elif command == 'SELECT' or command == 'EXAMINE':
+                        if not authenticated:
+                            client_socket.sendall(f"{tag} NO Not authenticated\r\n".encode())
+                            continue
+                        
+                        selected_mailbox = "INBOX"
+                        count = len(self.emails)
+                        client_socket.sendall(f"* {count} EXISTS\r\n".encode())
+                        client_socket.sendall(b"* 0 RECENT\r\n")
+                        client_socket.sendall(b"* FLAGS (\\Seen \\Answered \\Flagged \\Deleted \\Draft)\r\n")
+                        client_socket.sendall(f"{tag} OK [{command}] completed\r\n".encode())
+                    
+                    elif command == 'FETCH':
+                        if not authenticated or not selected_mailbox:
+                            client_socket.sendall(f"{tag} NO Not authenticated or no mailbox selected\r\n".encode())
+                            continue
+                        
+                        # Parse FETCH command: e.g., "1:* (FLAGS BODY[])"
+                        fetch_parts = args.split(' ', 1)
+                        sequence = fetch_parts[0]
+                        items = fetch_parts[1] if len(fetch_parts) > 1 else "(FLAGS)"
+                        
+                        # Simple implementation: fetch all emails
+                        for i, email_data in enumerate(self.emails, 1):
+                            response_items = []
+                            
+                            if 'FLAGS' in items:
+                                flags = ' '.join(email_data.get('flags', []))
+                                response_items.append(f"FLAGS ({flags})")
+                            
+                            if 'BODY[]' in items or 'RFC822' in items:
+                                raw = email_data.get('raw', '')
+                                if not raw:
+                                    # Construct simple email if raw not available
+                                    raw = f"From: {email_data.get('from', '')}\r\n"
+                                    raw += f"To: {email_data.get('to', '')}\r\n"
+                                    raw += f"Subject: {email_data.get('subject', '')}\r\n"
+                                    raw += f"\r\n{email_data.get('body', '')}"
+                                
+                                response_items.append(f"BODY[] {{{len(raw.encode())}}}\r\n{raw}")
+                            
+                            if 'BODY[HEADER.FIELDS (SUBJECT)]' in items or 'ENVELOPE' in items:
+                                subject = email_data.get('subject', '')
+                                response_items.append(f"BODY[HEADER.FIELDS (SUBJECT)] {{Subject: {subject}}}")
+                            
+                            response = f"* {i} FETCH ({' '.join(response_items)})\r\n"
+                            client_socket.sendall(response.encode())
+                        
+                        client_socket.sendall(f"{tag} OK FETCH completed\r\n".encode())
+                    
+                    elif command == 'SEARCH':
+                        if not authenticated or not selected_mailbox:
+                            client_socket.sendall(f"{tag} NO Not authenticated or no mailbox selected\r\n".encode())
+                            continue
+                        
+                        # Simple SEARCH implementation - return all emails
+                        matches = ' '.join(str(i) for i in range(1, len(self.emails) + 1))
+                        client_socket.sendall(f"* SEARCH {matches}\r\n".encode())
+                        client_socket.sendall(f"{tag} OK SEARCH completed\r\n".encode())
+                    
+                    elif command == 'LOGOUT':
+                        client_socket.sendall(b"* BYE Logging out\r\n")
+                        client_socket.sendall(f"{tag} OK LOGOUT completed\r\n".encode())
+                        return
+                    
+                    else:
+                        client_socket.sendall(f"{tag} BAD Command not recognized\r\n".encode())
+        
+        except Exception as e:
+            print(f"[EmailMockServer] IMAP client error: {e}")
+        finally:
+            client_socket.close()
+        
+    def _create_http_handler(self):
+        """Create the HTTP request handler with access to this server instance."""
+        server_instance = self
+        
+        class EmailMockHandler(BaseHTTPRequestHandler):
+            def log_message(self, format, *args):
+                """Suppress default logging."""
+                pass
+                
+            def _send_json_response(self, status: int, data: Any):
+                """Send a JSON response."""
+                self.send_response(status)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Access-Control-Allow-Origin", "*")
+                self.end_headers()
+                self.wfile.write(json.dumps(data).encode())
+                
+            def do_OPTIONS(self):
+                """Handle CORS preflight requests."""
+                self.send_response(200)
+                self.send_header("Access-Control-Allow-Origin", "*")
+                self.send_header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS")
+                self.send_header("Access-Control-Allow-Headers", "Content-Type")
+                self.end_headers()
+                
+            def do_POST(self):
+                """Handle POST requests to capture emails."""
+                if self.path == "/send":
+                    content_length = int(self.headers.get("Content-Length", 0))
+                    body = self.rfile.read(content_length).decode("utf-8")
+                    
+                    try:
+                        email_data = json.loads(body)
+                        email_data["received_at"] = datetime.utcnow().isoformat()
+                        email_data["index"] = len(server_instance.emails)
+                        server_instance.emails.append(email_data)
+                        
+                        print(f"[EmailMockServer] Captured email #{email_data['index']}: "
+                              f"to={email_data.get('to', 'N/A')}, "
+                              f"subject={email_data.get('subject', 'N/A')}")
+                        
+                        self._send_json_response(200, {
+                            "status": "success",
+                            "message": "Email captured",
+                            "index": email_data["index"]
+                        })
+                    except json.JSONDecodeError:
+                        self._send_json_response(400, {
+                            "status": "error",
+                            "message": "Invalid JSON"
+                        })
+                else:
+                    self._send_json_response(404, {
+                        "status": "error",
+                        "message": "Not found"
+                    })
+                    
+            def do_GET(self):
+                """Handle GET requests to query emails."""
+                if self.path == "/emails":
+                    self._send_json_response(200, {
+                        "count": len(server_instance.emails),
+                        "emails": server_instance.emails
+                    })
+                elif self.path.startswith("/emails/"):
+                    try:
+                        index = int(self.path.split("/")[-1])
+                        email = server_instance.get_email(index)
+                        if email:
+                            self._send_json_response(200, email)
+                        else:
+                            self._send_json_response(404, {
+                                "status": "error",
+                                "message": f"Email at index {index} not found"
+                            })
+                    except ValueError:
+                        self._send_json_response(400, {
+                            "status": "error",
+                            "message": "Invalid index"
+                        })
+                elif self.path == "/health":
+                    self._send_json_response(200, {
+                        "status": "healthy",
+                        "emails_count": len(server_instance.emails)
+                    })
+                else:
+                    self._send_json_response(404, {
+                        "status": "error",
+                        "message": "Not found"
+                    })
+                    
+            def do_DELETE(self):
+                """Handle DELETE requests to clear emails."""
+                if self.path == "/emails":
+                    server_instance.clear()
+                    self._send_json_response(200, {
+                        "status": "success",
+                        "message": "All emails cleared"
+                    })
+                else:
+                    self._send_json_response(404, {
+                        "status": "error",
+                        "message": "Not found"
+                    })
+        
+        return EmailMockHandler

sefrone_api_e2e-1.0.4/sefrone_api_e2e/json_mock_server.py

@@ -0,0 +1,309 @@
+import threading
+import json
+import re
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from typing import List, Dict, Any, Optional, Callable
+from datetime import datetime
+from urllib.parse import urlparse, parse_qs
+
+
+class JsonMockServer:
+    """
+    Simple mock JSON/REST API server that can mock endpoints and record requests.
+    
+    Features:
+    - Configure mock endpoints with expected responses
+    - Record all incoming requests for verification
+    - Query recorded requests
+    - Support for dynamic response functions
+    - Pattern matching for URLs
+    """
+    
+    def __init__(self, host: str = "localhost", port: int = 8080):
+        self.host = host
+        self.port = port
+        self.mocks: List[Dict[str, Any]] = []
+        self.requests: List[Dict[str, Any]] = []
+        self._server: Optional[HTTPServer] = None
+        self._thread: Optional[threading.Thread] = None
+        self._running = False
+        
+    def start(self):
+        """Start the mock JSON server in a background thread."""
+        if self._running:
+            print(f"[JsonMockServer] Already running on {self.host}:{self.port}")
+            return
+            
+        handler = self._create_handler()
+        self._server = HTTPServer((self.host, self.port), handler)
+        self._running = True
+        
+        self._thread = threading.Thread(target=self._server.serve_forever, daemon=True)
+        self._thread.start()
+        print(f"[JsonMockServer] Started on http://{self.host}:{self.port}")
+        
+    def stop(self):
+        """Stop the mock JSON server."""
+        if not self._running:
+            return
+            
+        self._running = False
+        if self._server:
+            self._server.shutdown()
+            self._server.server_close()
+        if self._thread:
+            self._thread.join(timeout=2)
+        print(f"[JsonMockServer] Stopped")
+        
+    def clear_mocks(self):
+        """Clear all configured mocks."""
+        self.mocks.clear()
+        print(f"[JsonMockServer] Cleared all mocks")
+        
+    def clear_requests(self):
+        """Clear all recorded requests."""
+        self.requests.clear()
+        print(f"[JsonMockServer] Cleared all recorded requests")
+        
+    def clear_all(self):
+        """Clear both mocks and recorded requests."""
+        self.clear_mocks()
+        self.clear_requests()
+        
+    def add_mock(
+        self,
+        method: str,
+        path: str,
+        response_body: Any = None,
+        status_code: int = 200,
+        response_headers: Optional[Dict[str, str]] = None,
+        response_fn: Optional[Callable] = None,
+        is_regex: bool = False
+    ):
+        """
+        Add a mock endpoint.
+        
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE, etc.)
+            path: URL path or regex pattern
+            response_body: Response body to return (dict or any JSON-serializable)
+            status_code: HTTP status code to return
+            response_headers: Additional response headers
+            response_fn: Optional function(request_data) -> response_body for dynamic responses
+            is_regex: Whether path is a regex pattern
+            
+        Example:
+            server.add_mock("GET", "/api/users", {"users": []})
+            server.add_mock("POST", "/api/users", {"id": 1}, status_code=201)
+            server.add_mock("GET", r"/api/users/\d+", response_fn=lambda req: {"id": req["path_params"][0]}, is_regex=True)
+        """
+        mock = {
+            "method": method.upper(),
+            "path": path,
+            "response_body": response_body,
+            "status_code": status_code,
+            "response_headers": response_headers or {},
+            "response_fn": response_fn,
+            "is_regex": is_regex,
+            "hit_count": 0
+        }
+        self.mocks.append(mock)
+        print(f"[JsonMockServer] Added mock: {method.upper()} {path} -> {status_code}")
+        
+    def get_requests(self) -> List[Dict[str, Any]]:
+        """Get all recorded requests."""
+        return self.requests.copy()
+        
+    def get_request(self, index: int) -> Optional[Dict[str, Any]]:
+        """Get a specific request by index."""
+        if 0 <= index < len(self.requests):
+            return self.requests[index]
+        return None
+        
+    def count_requests(self, method: Optional[str] = None, path: Optional[str] = None) -> int:
+        """
+        Count recorded requests, optionally filtered by method and/or path.
+        
+        Example:
+            count_requests()  # all requests
+            count_requests(method="POST")
+            count_requests(path="/api/users")
+            count_requests(method="POST", path="/api/users")
+        """
+        filtered = self.requests
+        if method:
+            filtered = [r for r in filtered if r["method"] == method.upper()]
+        if path:
+            filtered = [r for r in filtered if r["path"] == path]
+        return len(filtered)
+        
+    def find_requests(self, **filters) -> List[Dict[str, Any]]:
+        """
+        Find requests matching the given filters.
+        
+        Example:
+            find_requests(method="POST", path="/api/users")
+        """
+        results = []
+        for request in self.requests:
+            match = True
+            for key, value in filters.items():
+                if key not in request or request[key] != value:
+                    match = False
+                    break
+            if match:
+                results.append(request)
+        return results
+        
+    def _find_mock(self, method: str, path: str) -> Optional[Dict[str, Any]]:
+        """Find a matching mock for the given method and path."""
+        for mock in self.mocks:
+            if mock["method"] != method:
+                continue
+                
+            if mock["is_regex"]:
+                if re.match(mock["path"], path):
+                    return mock
+            else:
+                if mock["path"] == path:
+                    return mock
+        return None
+        
+    def _create_handler(self):
+        """Create the HTTP request handler with access to this server instance."""
+        server_instance = self
+        
+        class JsonMockHandler(BaseHTTPRequestHandler):
+            def log_message(self, format, *args):
+                """Suppress default logging."""
+                pass
+                
+            def _send_json_response(self, status: int, data: Any, headers: Optional[Dict[str, str]] = None):
+                """Send a JSON response."""
+                self.send_response(status)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Access-Control-Allow-Origin", "*")
+                if headers:
+                    for key, value in headers.items():
+                        self.send_header(key, value)
+                self.end_headers()
+                self.wfile.write(json.dumps(data).encode())
+                
+            def do_OPTIONS(self):
+                """Handle CORS preflight requests."""
+                self.send_response(200)
+                self.send_header("Access-Control-Allow-Origin", "*")
+                self.send_header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS")
+                self.send_header("Access-Control-Allow-Headers", "Content-Type, Authorization")
+                self.end_headers()
+                
+            def _handle_request(self, method: str):
+                """Common request handling logic."""
+                parsed_url = urlparse(self.path)
+                path = parsed_url.path
+                query_params = parse_qs(parsed_url.query)
+                
+                # Read request body if present
+                body = None
+                content_length = int(self.headers.get("Content-Length", 0))
+                if content_length > 0:
+                    body_bytes = self.rfile.read(content_length)
+                    try:
+                        body = json.loads(body_bytes.decode("utf-8"))
+                    except json.JSONDecodeError:
+                        body = body_bytes.decode("utf-8")
+                
+                # Record the request
+                request_data = {
+                    "index": len(server_instance.requests),
+                    "method": method,
+                    "path": path,
+                    "query_params": query_params,
+                    "headers": dict(self.headers),
+                    "body": body,
+                    "received_at": datetime.utcnow().isoformat()
+                }
+                server_instance.requests.append(request_data)
+                
+                print(f"[JsonMockServer] Recorded request #{request_data['index']}: {method} {path}")
+                
+                # Special endpoint to query recorded requests
+                if path == "/_mock/requests":
+                    self._send_json_response(200, {
+                        "count": len(server_instance.requests),
+                        "requests": server_instance.requests
+                    })
+                    return
+                elif path.startswith("/_mock/requests/"):
+                    try:
+                        index = int(path.split("/")[-1])
+                        request = server_instance.get_request(index)
+                        if request:
+                            self._send_json_response(200, request)
+                        else:
+                            self._send_json_response(404, {
+                                "status": "error",
+                                "message": f"Request at index {index} not found"
+                            })
+                        return
+                    except ValueError:
+                        self._send_json_response(400, {
+                            "status": "error",
+                            "message": "Invalid index"
+                        })
+                        return
+                elif path == "/_mock/health":
+                    self._send_json_response(200, {
+                        "status": "healthy",
+                        "mocks_count": len(server_instance.mocks),
+                        "requests_count": len(server_instance.requests)
+                    })
+                    return
+                
+                # Find matching mock
+                mock = server_instance._find_mock(method, path)
+                if mock:
+                    mock["hit_count"] += 1
+                    
+                    # Generate response
+                    if mock["response_fn"]:
+                        try:
+                            response_body = mock["response_fn"](request_data)
+                        except Exception as e:
+                            self._send_json_response(500, {
+                                "status": "error",
+                                "message": f"Mock response function error: {str(e)}"
+                            })
+                            return
+                    else:
+                        response_body = mock["response_body"]
+                    
+                    print(f"[JsonMockServer] Matched mock: {method} {path} -> {mock['status_code']}")
+                    self._send_json_response(
+                        mock["status_code"],
+                        response_body,
+                        mock["response_headers"]
+                    )
+                else:
+                    print(f"[JsonMockServer] No mock found for: {method} {path}")
+                    self._send_json_response(404, {
+                        "status": "error",
+                        "message": f"No mock configured for {method} {path}"
+                    })
+                    
+            def do_GET(self):
+                self._handle_request("GET")
+                
+            def do_POST(self):
+                self._handle_request("POST")
+                
+            def do_PUT(self):
+                self._handle_request("PUT")
+                
+            def do_DELETE(self):
+                self._handle_request("DELETE")
+                
+            def do_PATCH(self):
+                self._handle_request("PATCH")
+        
+        return JsonMockHandler

{sefrone_api_e2e-1.0.2 → sefrone_api_e2e-1.0.4}/sefrone_api_e2e.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sefrone-api-e2e
-Version: 1.0.2
+Version: 1.0.4
 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.2 → sefrone_api_e2e-1.0.4}/sefrone_api_e2e.egg-info/SOURCES.txt

@@ -2,6 +2,8 @@ README.md
 setup.py
 sefrone_api_e2e/__init__.py
 sefrone_api_e2e/api_e2e_manager.py
+sefrone_api_e2e/email_mock_server.py
+sefrone_api_e2e/json_mock_server.py
 sefrone_api_e2e.egg-info/PKG-INFO
 sefrone_api_e2e.egg-info/SOURCES.txt
 sefrone_api_e2e.egg-info/dependency_links.txt

{sefrone_api_e2e-1.0.2 → sefrone_api_e2e-1.0.4}/setup.py

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

sefrone_api_e2e-1.0.2/sefrone_api_e2e/__init__.py

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