socialseed-e2e 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

socialseed_e2e/templates/verify_installation.py

@@ -0,0 +1,192 @@
+"""Installation verification script for socialseed-e2e framework.
+
+This script verifies that the framework is properly installed and configured,
+and that all components work correctly.
+
+Usage:
+    python verify_installation.py
+
+Or after e2e init:
+    python verify_setup.py
+"""
+
+import importlib
+import sys
+from pathlib import Path
+
+
+def check_color(text: str, color: str) -> str:
+    """Add color to text for terminal output."""
+    colors = {
+        "green": "\033[92m",
+        "red": "\033[91m",
+        "yellow": "\033[93m",
+        "blue": "\033[94m",
+        "reset": "\033[0m",
+    }
+    return f"{colors.get(color, '')}{text}{colors['reset']}"
+
+
+def print_section(title: str):
+    """Print a section header."""
+    print(f"\n{'=' * 60}")
+    print(f"  {title}")
+    print(f"{'=' * 60}")
+
+
+def print_check(name: str, status: bool, message: str = ""):
+    """Print a check result."""
+    symbol = "✓" if status else "✗"
+    color = "green" if status else "red"
+    msg = f" - {message}" if message else ""
+    print(f"  {check_color(symbol, color)} {name}{msg}")
+
+
+def verify_installation():
+    """Run all verification checks."""
+    all_passed = True
+
+    print("\n" + "=" * 60)
+    print("  SocialSeed E2E Framework - Installation Verification")
+    print("=" * 60)
+
+    # 1. Check Python version
+    print_section("Python Environment")
+    version = sys.version_info
+    python_ok = version.major == 3 and version.minor >= 10
+    print_check(f"Python {version.major}.{version.minor}.{version.micro}", python_ok)
+    all_passed = all_passed and python_ok
+
+    # 2. Check required packages
+    print_section("Required Packages")
+    required_packages = [
+        ("pydantic", "Pydantic v2"),
+        ("email_validator", "Email Validator"),
+    ]
+
+    for package, display_name in required_packages:
+        try:
+            importlib.import_module(package)
+            print_check(f"{display_name}", True)
+        except ImportError:
+            print_check(f"{display_name}", False, f"Not installed. Run: pip install {package}")
+            all_passed = False
+
+    # 3. Check framework packages
+    print_section("Framework Packages")
+    try:
+        importlib.import_module("socialseed_e2e")
+        print_check("socialseed_e2e (framework)", True)
+    except ImportError:
+        print_check("socialseed_e2e", False, "Framework not installed")
+        print("  → Install with: pip install socialseed-e2e")
+        all_passed = False
+
+    # 4. Check project structure
+    print_section("Project Structure")
+
+    project_root = Path(".").resolve()
+    required_paths = [
+        ("e2e.conf", "Configuration file"),
+        ("services/", "Services directory"),
+        ("requirements.txt", "Dependencies file"),
+        (".agent/AGENT_GUIDE.md", "AI Agent guide"),
+        (".agent/EXAMPLE_TEST.md", "Example documentation"),
+    ]
+
+    for path, description in required_paths:
+        full_path = project_root / path
+        exists = full_path.exists()
+        print_check(f"{path} ({description})", exists)
+        if not exists:
+            all_passed = False
+
+    # 5. Test Pydantic alias serialization
+    print_section("Pydantic Alias Serialization Test")
+    try:
+        from pydantic import BaseModel, Field
+
+        class TestModel(BaseModel):
+            model_config = {"populate_by_name": True}
+            field_name: str = Field(alias="fieldName", serialization_alias="fieldName")
+
+        # Test serialization
+        instance = TestModel(field_name="test")
+        data = instance.model_dump(by_alias=True)
+
+        if "fieldName" in data and data["fieldName"] == "test":
+            print_check("CamelCase serialization", True)
+        else:
+            print_check("CamelCase serialization", False, "alias not working correctly")
+            all_passed = False
+
+        # Test deserialization
+        instance2 = TestModel(fieldName="test2")
+        if instance2.field_name == "test2":
+            print_check("Field population by name", True)
+        else:
+            print_check("Field population by name", False, "populate_by_name not working")
+            all_passed = False
+
+    except Exception as e:
+        print_check("Pydantic configuration", False, str(e))
+        all_passed = False
+
+    # 6. Check for common issues
+    print_section("Common Issues Check")
+
+    # Check for relative imports in services
+    services_dir = project_root / "services"
+    if services_dir.exists():
+        has_relative_imports = False
+        for py_file in services_dir.rglob("*.py"):
+            if py_file.name.startswith("_"):
+                continue
+            try:
+                content = py_file.read_text()
+                if "from .." in content or "from . import" in content:
+                    if py_file.name != "__init__.py":
+                        has_relative_imports = True
+                        print_check(
+                            f"Relative imports in {py_file}",
+                            False,
+                            "Use absolute imports",
+                        )
+            except Exception:
+                pass
+
+        if not has_relative_imports:
+            print_check("No relative imports found", True)
+
+    # 7. Services check
+    print_section("Configured Services")
+    if services_dir.exists():
+        services = [d.name for d in services_dir.iterdir() if d.is_dir()]
+        if services:
+            for service in services:
+                print_check(f"Service: {service}", True)
+        else:
+            print("  ℹ No services configured yet")
+            print("  → Create with: e2e new-service <name>")
+
+    # Final summary
+    print("\n" + "=" * 60)
+    if all_passed:
+        print(check_color("  ✓ All checks passed! Installation is ready.", "green"))
+        print("\n  🎉 You can now:")
+        print("     • Run: e2e new-service <name> to create a service")
+        print("     • Ask your AI agent to generate tests")
+        print("     • Read .agent/AGENT_GUIDE.md for patterns")
+    else:
+        print(check_color("  ✗ Some checks failed. Please review issues above.", "red"))
+        print("\n  🔧 To fix:")
+        print("     • Install dependencies: pip install -r requirements.txt")
+        print("     • Review .agent/AGENT_GUIDE.md for correct patterns")
+    print("=" * 60)
+
+    return all_passed
+
+
+if __name__ == "__main__":
+    success = verify_installation()
+    sys.exit(0 if success else 1)

socialseed_e2e/utils/__init__.py

@@ -1,5 +1,19 @@
 """Utility functions for socialseed-e2e."""
 
+from .pydantic_helpers import (
+    JavaCompatibleModel,
+    camel_field,
+    created_at_field,
+    current_password_field,
+    new_password_field,
+    refresh_token_field,
+    to_camel_dict,
+    updated_at_field,
+    user_id_field,
+    user_name_field,
+    validate_camelcase_model,
+)
+from .state_management import AuthStateMixin, DynamicStateMixin
 from .template_engine import TemplateEngine, to_camel_case, to_class_name, to_snake_case
 from .validators import (
     ValidationError,
@@ -20,6 +34,21 @@ from .validators import (
 )
 
 __all__ = [
+    # State management
+    "DynamicStateMixin",
+    "AuthStateMixin",
+    # Pydantic helpers for Java compatibility
+    "JavaCompatibleModel",
+    "camel_field",
+    "to_camel_dict",
+    "validate_camelcase_model",
+    "refresh_token_field",
+    "user_name_field",
+    "user_id_field",
+    "created_at_field",
+    "updated_at_field",
+    "new_password_field",
+    "current_password_field",
     # Template engine
     "TemplateEngine",
     "to_class_name",

socialseed_e2e/utils/ai_generator.py

@@ -0,0 +1,463 @@
+"""AI Code Generation Helper for socialseed-e2e.
+
+This module provides intelligent code generation for AI agents
+to automatically create tests from REST controller analysis.
+"""
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+
+@dataclass
+class EndpointInfo:
+    """Information about a REST endpoint."""
+
+    method: str
+    path: str
+    name: str
+    request_dto: Optional[str] = None
+    response_dto: Optional[str] = None
+    requires_auth: bool = False
+    path_params: List[str] = None
+    query_params: List[str] = None
+
+
+@dataclass
+class DtoField:
+    """Field information for DTO generation."""
+
+    name: str
+    type_hint: str
+    required: bool = True
+    validations: List[str] = None
+
+
+class JavaControllerParser:
+    """Parser for Java Spring Boot controllers."""
+
+    @staticmethod
+    def parse_controller(java_code: str) -> List[EndpointInfo]:
+        """Parse Java controller code and extract endpoints.
+
+        Args:
+            java_code: Java source code
+
+        Returns:
+            List of EndpointInfo objects
+        """
+        endpoints = []
+
+        # Even more robust regex for Spring Boot methods
+        method_pattern = r'@(?:Post|Get|Put|Delete|Patch)Mapping\s*\(\s*(?:(?:value|path)\s*=\s*)?"([^"]+)"[^)]*\)\s*(?:@[^;{]+\s+)*?(?:public\s+)?\s*(?:ResponseEntity<[^>]+>|[\w<>\?]+)\s+(\w+)\s*\(([^)]*)\)'
+
+        # We need to find the HTTP method separately because we removed it from the capturing group to simplify the regex
+        all_mapping_patterns = [
+            (r"@PostMapping", "POST"),
+            (r"@GetMapping", "GET"),
+            (r"@PutMapping", "PUT"),
+            (r"@DeleteMapping", "DELETE"),
+            (r"@PatchMapping", "PATCH"),
+        ]
+
+        for mapping_tag, http_method in all_mapping_patterns:
+            pattern = (
+                mapping_tag
+                + r'\s*\(\s*(?:(?:value|path)\s*=\s*)?"([^"]+)"[^)]*\)\s*(?:@[^;{]+\s+)*?(?:public\s+)?\s*(?:ResponseEntity<[^>]+>|[\w<>\?]+)\s+(\w+)\s*\(([^)]*)\)'
+            )
+            matches = re.finditer(pattern, java_code, re.MULTILINE | re.DOTALL)
+            for match in matches:
+                path = match.group(1)
+                method_name = match.group(2)
+                arguments = match.group(3)
+
+                # Check for @RequestBody
+                request_dto = None
+                request_body_match = re.search(
+                    r"@RequestBody\s+(?:@\w+\s+)*(\w+)\s+(\w+)", arguments
+                )
+                if request_body_match:
+                    request_dto = request_body_match.group(1)
+
+                # Check for authentication requirements
+                requires_auth = (
+                    "@PreAuthorize" in java_code or "@AuthenticationPrincipal" in java_code
+                )
+
+                # Extract path parameters
+                path_params = re.findall(r"\{(\w+)\}", path)
+
+                endpoints.append(
+                    EndpointInfo(
+                        method=http_method,
+                        path=path,
+                        name=method_name,
+                        request_dto=request_dto,
+                        requires_auth=requires_auth,
+                        path_params=path_params,
+                    )
+                )
+
+        return endpoints
+
+    @staticmethod
+    def parse_dto(java_code: str, dto_name: str) -> List[DtoField]:
+        """Parse a Java DTO and extract fields.
+
+        Args:
+            java_code: Java DTO source code
+            dto_name: Name of the DTO class
+
+        Returns:
+            List of DtoField objects
+        """
+        fields = []
+
+        # Pattern for record fields
+        record_pattern = rf"record\s+{dto_name}\s*\(\s*([^)]+)\)"
+        record_match = re.search(record_pattern, java_code, re.DOTALL)
+
+        if record_match:
+            # Parse record components
+            components = record_match.group(1)
+            # Split by comma, but be careful with generics
+            # Improved regex to capture annotations for each field
+            field_defs = re.findall(
+                r"((?:@\w+(?:\([^)]*\))?\s*)*)(\w+(?:<[^>]+>)?)\s+(\w+)", components
+            )
+
+            for annotations, type_hint, name in field_defs:
+                # Map Java types to Python
+                py_type = JavaControllerParser._map_java_type(type_hint.strip())
+
+                # Check for @Email specifically in this field's annotations
+                if "@Email" in annotations and py_type == "str":
+                    py_type = "EmailStr"
+
+                fields.append(DtoField(name=name, type_hint=py_type, required=True))
+
+        return fields
+
+    @staticmethod
+    def _map_java_type(java_type: str) -> str:
+        """Map Java types to Python type hints."""
+        type_mapping = {
+            "String": "str",
+            "Integer": "int",
+            "int": "int",
+            "Long": "int",
+            "long": "int",
+            "Boolean": "bool",
+            "boolean": "bool",
+            "Double": "float",
+            "double": "float",
+            "Float": "float",
+            "float": "float",
+            "UUID": "UUID",
+            "Instant": "datetime",
+            "LocalDateTime": "datetime",
+            "Set": "Set",
+            "List": "List",
+            "Map": "Dict",
+        }
+
+        # Handle generics
+        for java, python in type_mapping.items():
+            if java_type.startswith(java + "<"):
+                inner_type = java_type[java_type.find("<") + 1 : java_type.rfind(">")]
+                inner_python = JavaControllerParser._map_java_type(inner_type.strip())
+                return f"{python}[{inner_python}]"
+            elif java_type == java:
+                return python
+
+        return "str"  # Default to str
+
+
+class PythonCodeGenerator:
+    """Generator for Python test code."""
+
+    @staticmethod
+    def generate_data_schema(
+        endpoints: List[EndpointInfo],
+        dto_definitions: Dict[str, List[DtoField]],
+        service_name: str,
+    ) -> str:
+        """Generate data_schema.py content.
+
+        Args:
+            endpoints: List of endpoints
+            dto_definitions: Dictionary mapping DTO names to fields
+            service_name: Name of the service
+
+        Returns:
+            Python code for data_schema.py
+        """
+        lines = [
+            '"""Data schema for {} API.'.format(service_name),
+            "",
+            "Auto-generated from Java controller analysis.",
+            '"""',
+            "from pydantic import BaseModel, Field, EmailStr",
+            "from typing import Optional, Set, List, Dict",
+            "from datetime import datetime",
+            "from uuid import UUID",
+            "",
+            "",
+            "# =============================================================================",
+            "# Request DTOs",
+            "# =============================================================================",
+            "",
+        ]
+
+        # Generate request DTOs
+        generated_dtos = set()
+        for endpoint in endpoints:
+            if endpoint.request_dto and endpoint.request_dto not in generated_dtos:
+                dto_name = endpoint.request_dto.replace("DTO", "Request")
+                fields = dto_definitions.get(endpoint.request_dto, [])
+
+                lines.append(f"class {dto_name}(BaseModel):")
+                lines.append(f'    """{endpoint.request_dto} request."""')
+                lines.append('    model_config = {"populate_by_name": True}')
+                lines.append("")
+
+                for field in fields:
+                    if field.name in [
+                        "refresh_token",
+                        "access_token",
+                        "new_password",
+                        "current_password",
+                        "user_id",
+                        "created_at",
+                        "updated_at",
+                        "last_login_at",
+                    ]:
+                        # Use camelCase alias
+                        camel_name = PythonCodeGenerator._to_camel_case(field.name)
+                        lines.append(f"    {field.name}: {field.type_hint} = Field(")
+                        lines.append(f"        ...,")
+                        lines.append(f'        alias="{camel_name}",')
+                        lines.append(f'        serialization_alias="{camel_name}"')
+                        lines.append(f"    )")
+                    else:
+                        lines.append(f"    {field.name}: {field.type_hint}")
+
+                lines.append("")
+                lines.append("")
+                generated_dtos.add(endpoint.request_dto)
+
+        # Generate ENDPOINTS constant
+        lines.append(
+            "# ============================================================================="
+        )
+        lines.append("# Endpoint Constants")
+        lines.append(
+            "# ============================================================================="
+        )
+        lines.append("")
+        lines.append("ENDPOINTS = {")
+
+        for endpoint in endpoints:
+            key = endpoint.name.lower().replace("get", "get_").replace("post", "create_")
+            key = (
+                key.replace("put", "update_")
+                .replace("delete", "delete_")
+                .replace("patch", "patch_")
+            )
+            key = re.sub(r"([a-z])([A-Z])", r"\1_\2", key).lower()
+
+            lines.append(f'    "{key}": "{endpoint.path}",')
+
+        lines.append("}")
+        lines.append("")
+        lines.append("")
+
+        # Generate TEST_DATA
+        lines.append(
+            "# ============================================================================="
+        )
+        lines.append("# Test Data")
+        lines.append(
+            "# ============================================================================="
+        )
+        lines.append("")
+        lines.append("TEST_DATA = {")
+        lines.append('    "user": {')
+        lines.append('        "username": "testuser_e2e",')
+        lines.append('        "email": "testuser_e2e@example.com",')
+        lines.append('        "password": "TestPassword123!"')
+        lines.append("    }")
+        lines.append("}")
+        lines.append("")
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def generate_page_class(
+        endpoints: List[EndpointInfo], service_name: str, service_class_name: str
+    ) -> str:
+        """Generate page class content.
+
+        Args:
+            endpoints: List of endpoints
+            service_name: Name of the service
+            service_class_name: PascalCase service name
+
+        Returns:
+            Python code for {service}_page.py
+        """
+        lines = [
+            '"""Page object for {} API.""".format(service_name)',
+            "from typing import Optional, Dict, Any",
+            "from playwright.sync_api import APIResponse",
+            "from socialseed_e2e import BasePage",
+            "",
+            "from services.{}.data_schema import (".format(service_name),
+            "    ENDPOINTS,",
+        ]
+
+        # Import request DTOs
+        for endpoint in endpoints:
+            if endpoint.request_dto:
+                dto_name = endpoint.request_dto.replace("DTO", "Request")
+                lines.append(f"    {dto_name},")
+
+        lines.append(")")
+        lines.append("")
+        lines.append("")
+        lines.append(f"class {service_class_name}Page(BasePage):")
+        lines.append(f'    """Page object for {service_name} service API."""')
+        lines.append("")
+        lines.append("    def __init__(self, base_url: str, **kwargs):")
+        lines.append("        super().__init__(base_url=base_url, **kwargs)")
+        lines.append("        self.access_token: Optional[str] = None")
+        lines.append("        self.current_user: Optional[Dict[str, Any]] = None")
+        lines.append("")
+        lines.append("    def _get_headers(self, extra: Optional[Dict] = None) -> Dict[str, str]:")
+        lines.append('        """Build headers with authentication if available."""')
+        lines.append('        headers = {"Content-Type": "application/json"}')
+        lines.append("        if self.access_token:")
+        lines.append('            headers["Authorization"] = f"Bearer {self.access_token}"')
+        lines.append("        if extra:")
+        lines.append("            headers.update(extra)")
+        lines.append("        return headers")
+        lines.append("")
+
+        # Generate methods for each endpoint
+        for endpoint in endpoints:
+            method_name = PythonCodeGenerator._generate_method_name(endpoint)
+            lines.append(f"    def {method_name}(self, request) -> APIResponse:")
+            lines.append(f'        """{endpoint.name} endpoint."""')
+
+            # Handle path parameters
+            path = endpoint.path
+            if endpoint.path_params:
+                for param in endpoint.path_params:
+                    path = path.replace(f"{{{param}}}", f"{{{param}}}")
+                lines.append(
+                    f'        path = ENDPOINTS["{key}"].format({", ".join(endpoint.path_params)})'
+                )
+                lines.append(
+                    f"        response = self.{endpoint.method.lower()}(path, data=request.model_dump(by_alias=True))"
+                )
+            else:
+                key = endpoint.name.lower().replace("get", "get_").replace("post", "create_")
+                key = (
+                    key.replace("put", "update_")
+                    .replace("delete", "delete_")
+                    .replace("patch", "patch_")
+                )
+                key = re.sub(r"([a-z])([A-Z])", r"\1_\2", key).lower()
+                lines.append(f"        response = self.{endpoint.method.lower()}(")
+                lines.append(f'            ENDPOINTS["{key}"],')
+                lines.append(
+                    f"            data=request.model_dump(by_alias=True)  # ✅ SIEMPRE by_alias=True"
+                )
+                lines.append(f"        )")
+
+            lines.append("        return response")
+            lines.append("")
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def _to_camel_case(snake_str: str) -> str:
+        """Convert snake_case to camelCase."""
+        components = snake_str.split("_")
+        return components[0] + "".join(x.capitalize() for x in components[1:])
+
+    @staticmethod
+    def _generate_method_name(endpoint: EndpointInfo) -> str:
+        """Generate Python method name from endpoint info."""
+        prefix = "do_"
+
+        # Map HTTP methods to action verbs
+        if endpoint.method == "GET":
+            if "ById" in endpoint.name or "By" in endpoint.name:
+                action = "get"
+            else:
+                action = "list"
+        elif endpoint.method == "POST":
+            action = "create"
+        elif endpoint.method == "PUT":
+            action = "update"
+        elif endpoint.method == "PATCH":
+            action = "patch"
+        elif endpoint.method == "DELETE":
+            action = "delete"
+        else:
+            action = endpoint.method.lower()
+
+        # Extract resource name
+        name = endpoint.name
+        name = re.sub(r"^(get|post|put|delete|patch)", "", name, flags=re.IGNORECASE)
+        name = re.sub(r"([a-z])([A-Z])", r"\1_\2", name).lower()
+
+        return f"{prefix}{action}_{name}".rstrip("_")
+
+
+class AICodeGenerator:
+    """Main class for AI-assisted code generation."""
+
+    @staticmethod
+    def analyze_and_generate(
+        controller_code: str, dto_codes: Dict[str, str], service_name: str
+    ) -> Dict[str, str]:
+        """Analyze Java code and generate Python test code.
+
+        Args:
+            controller_code: Java controller source code
+            dto_codes: Dictionary of DTO name to source code
+            service_name: Name of the service
+
+        Returns:
+            Dictionary with 'data_schema' and 'page_class' keys
+        """
+        # Parse controller
+        endpoints = JavaControllerParser.parse_controller(controller_code)
+
+        # Parse DTOs
+        dto_definitions = {}
+        for dto_name, dto_code in dto_codes.items():
+            fields = JavaControllerParser.parse_dto(dto_code, dto_name)
+            dto_definitions[dto_name] = fields
+
+        # Generate service class name
+        service_class_name = "".join(word.capitalize() for word in service_name.split("_"))
+
+        # Generate code
+        data_schema = PythonCodeGenerator.generate_data_schema(
+            endpoints, dto_definitions, service_name
+        )
+
+        page_class = PythonCodeGenerator.generate_page_class(
+            endpoints, service_name, service_class_name
+        )
+
+        return {
+            "data_schema": data_schema,
+            "page_class": page_class,
+            "endpoints": endpoints,
+            "dto_definitions": dto_definitions,
+        }