socialseed-e2e 0.1.0__py3-none-any.whl

socialseed_e2e/core/models.py

@@ -0,0 +1,24 @@
+from typing import Any, Dict, Optional, Protocol, runtime_checkable
+
+from pydantic import BaseModel, Field
+
+
+class ServiceConfig(BaseModel):
+    """Configuration for a specific service."""
+
+    name: str
+    base_url: str
+    default_headers: Dict[str, str] = Field(default_factory=dict)
+    timeout: int = 30000
+    extra: Dict[str, Any] = Field(default_factory=dict)
+
+
+class TestContext(BaseModel):
+    """Generic context for test execution."""
+
+    env: str = "dev"
+    services: Dict[str, ServiceConfig] = Field(default_factory=dict)
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+    def get_service(self, name: str) -> Optional[ServiceConfig]:
+        return self.services.get(name)

socialseed_e2e/core/test_orchestrator.py

@@ -0,0 +1,84 @@
+import importlib.util
+import os
+import sys
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+try:
+    import pytest
+except ImportError:
+    pytest = None
+
+
+from socialseed_e2e.core.loaders import ModuleLoader
+
+
+class TestOrchestrator:
+    """
+    Orchestrates dynamic loading and execution of test modules.
+    Auto-discovers modules in services/*/modules/ and runs them.
+    """
+
+    def __init__(
+        self, root_dir: Optional[str] = None, services_path: str = "verify_services/e2e/services"
+    ):
+        # Default to the directory containing the 'verify_services' folder or current working directory
+        self.root_dir = Path(root_dir) if root_dir else Path(os.getcwd())
+        self.services_dir = self.root_dir / services_path
+        self.loader = ModuleLoader()
+        self.modules: Dict[str, List[Callable]] = {}
+
+    def discover_modules(self):
+        """Discover all test modules in services directories using dynamic file loading."""
+        if not self.services_dir.exists():
+            print(f"Warning: Services directory not found at {self.services_dir}")
+            return
+
+        for service_dir in self.services_dir.iterdir():
+            if service_dir.is_dir():
+                modules_dir = service_dir / "modules"
+                if modules_dir.exists():
+                    service_name = service_dir.name
+                    self.modules[service_name] = self.loader.discover_runnables(modules_dir)
+
+    def run_service_tests(self, service_name: str, context: Any):
+        """Run all modules for a specific service."""
+        if service_name not in self.modules:
+            raise ValueError(
+                f"Service {service_name} not found or has no modules discovered at {self.services_dir}"
+            )
+        for run_func in self.modules[service_name]:
+            run_func(context)
+
+    def run_all_tests(self, context_factory: Callable[[], Any]):
+        """Run all discovered tests with a context factory."""
+        for service_name, modules in self.modules.items():
+            context = context_factory()
+            try:
+                for run_func in modules:
+                    run_func(context)
+                print(f"✓ {service_name} tests passed")
+            except Exception as e:
+                print(f"✗ {service_name} tests failed: {e}")
+                raise
+            finally:
+                if hasattr(context, "teardown"):
+                    context.teardown()
+
+
+# Pytest integration
+def pytest_configure(config):
+    """Hook to set up orchestrator for pytest."""
+    if pytest:
+        # Configuration can be passed via environment variables
+        root = os.getenv("E2E_ROOT_DIR")
+        spath = os.getenv("E2E_SERVICES_PATH", "verify_services/e2e/services")
+        config.orchestrator = TestOrchestrator(root_dir=root, services_path=spath)
+
+
+def pytest_collection_modifyitems(config, items):
+    """Modify test collection to include dynamic modules."""
+    if pytest:
+        orchestrator = getattr(config, "orchestrator", None)
+        if orchestrator:
+            orchestrator.discover_modules()

socialseed_e2e/services/__init__.py

@@ -0,0 +1,9 @@
+# E2E Testing Framework - Services
+# ==================================
+#
+# This package contains service-specific test implementations.
+# Each service has its own directory with:
+#   - config.py: Service configuration
+#   - data_schema.py: Pydantic models
+#   - {service}_page.py: Page object
+#   - modules/: Test modules

socialseed_e2e/templates/__init__.py

@@ -0,0 +1,32 @@
+"""Templates for code scaffolding.
+
+This package contains template files used by the TemplateEngine
+to generate code files and project scaffolding.
+
+Available Templates:
+    - e2e.conf.template: Default configuration file
+    - service_page.py.template: Service page class
+    - test_module.py.template: Test module structure
+    - data_schema.py.template: Data transfer objects
+    - config.py.template: Service configuration loader
+
+Usage:
+    Templates are loaded and rendered by the TemplateEngine class
+    in socialseed_e2e.utils.template_engine.
+
+Example:
+    from socialseed_e2e.utils import TemplateEngine
+
+    engine = TemplateEngine()
+    content = engine.render('service_page.py', {
+        'service_name': 'users-api',
+        'class_name': 'UsersApi'
+    })
+"""
+
+from pathlib import Path
+
+# Get the templates directory
+TEMPLATES_DIR = Path(__file__).parent
+
+__all__ = ["TEMPLATES_DIR"]

socialseed_e2e/templates/config.py.template

@@ -0,0 +1,20 @@
+"""Configuration loader for ${service_name}.
+
+This module provides configuration loading specific to the ${service_name} service.
+"""
+
+from socialseed_e2e.core.config_loader import ApiConfigLoader, ServiceConfig
+
+
+def get_${snake_case_name}_config() -> ServiceConfig:
+    """Get configuration for ${service_name} service.
+
+    Returns:
+        ServiceConfig: Configuration object for the service
+
+    Raises:
+        ConfigError: If configuration cannot be loaded
+    """
+    loader = ApiConfigLoader()
+    config = loader.load()
+    return config.services["${service_name}"]

socialseed_e2e/templates/data_schema.py.template

@@ -0,0 +1,116 @@
+"""Data schema and DTOs for ${service_name}.
+
+This module defines data transfer objects, validators, and constants
+for the ${service_name} service.
+"""
+
+from typing import Optional, List
+from pydantic import BaseModel, Field, validator
+
+
+class ${class_name}DTO(BaseModel):
+    """Data Transfer Object for ${service_name} entities.
+
+    Attributes:
+        id: Unique identifier
+        name: Entity name
+        description: Entity description
+        created_at: Creation timestamp
+        updated_at: Last update timestamp
+    """
+
+    id: Optional[str] = Field(None, description="Unique identifier")
+    name: str = Field(..., description="Entity name", min_length=1, max_length=100)
+    description: Optional[str] = Field(None, description="Entity description", max_length=500)
+    created_at: Optional[str] = Field(None, description="Creation timestamp (ISO format)")
+    updated_at: Optional[str] = Field(None, description="Last update timestamp (ISO format)")
+
+    @validator('name')
+    def name_must_not_be_empty(cls, v):
+        """Validate that name is not empty or whitespace."""
+        if not v or not v.strip():
+            raise ValueError('Name cannot be empty')
+        return v.strip()
+
+    class Config:
+        """Pydantic configuration."""
+        json_schema_extra = {
+            "example": {
+                "id": "123e4567-e89b-12d3-a456-426614174000",
+                "name": "Example Entity",
+                "description": "This is an example entity",
+                "created_at": "2025-01-31T12:00:00Z",
+                "updated_at": "2025-01-31T12:00:00Z"
+            }
+        }
+
+
+class ${class_name}CreateDTO(BaseModel):
+    """DTO for creating new ${service_name} entities.
+
+    Attributes:
+        name: Entity name (required)
+        description: Entity description (optional)
+    """
+
+    name: str = Field(..., description="Entity name", min_length=1, max_length=100)
+    description: Optional[str] = Field(None, description="Entity description", max_length=500)
+
+    @validator('name')
+    def name_must_not_be_empty(cls, v):
+        """Validate that name is not empty or whitespace."""
+        if not v or not v.strip():
+            raise ValueError('Name cannot be empty')
+        return v.strip()
+
+
+class ${class_name}UpdateDTO(BaseModel):
+    """DTO for updating existing ${service_name} entities.
+
+    Attributes:
+        name: Entity name (optional)
+        description: Entity description (optional)
+    """
+
+    name: Optional[str] = Field(None, description="Entity name", min_length=1, max_length=100)
+    description: Optional[str] = Field(None, description="Entity description", max_length=500)
+
+    @validator('name')
+    def name_must_not_be_empty_if_provided(cls, v):
+        """Validate that name is not empty if provided."""
+        if v is not None and not v.strip():
+            raise ValueError('Name cannot be empty')
+        return v.strip() if v else v
+
+
+class ${class_name}ListResponse(BaseModel):
+    """DTO for paginated list response.
+
+    Attributes:
+        items: List of entities
+        total: Total number of entities
+        page: Current page number
+        page_size: Number of items per page
+    """
+
+    items: List[${class_name}DTO] = Field(default_factory=list)
+    total: int = Field(0, ge=0)
+    page: int = Field(1, ge=1)
+    page_size: int = Field(10, ge=1, le=100)
+
+
+# Constants for ${service_name} service
+${constants}
+
+# Validation patterns
+VALIDATION_PATTERNS = {
+    "uuid": r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$',
+    "iso_timestamp": r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?$',
+}
+
+# Default values
+DEFAULTS = {
+    "page_size": 10,
+    "timeout": 5000,
+    "max_retries": 3,
+}

socialseed_e2e/templates/e2e.conf.template

@@ -0,0 +1,20 @@
+# Configuración E2E para socialseed-e2e
+# Documentación: https://github.com/daironpf/socialseed-e2e
+
+general:
+  # Entorno de ejecución (dev, staging, production)
+  environment: ${environment}
+
+  # Timeout global para requests en milisegundos
+  timeout: ${timeout}
+
+  # User agent para requests HTTP
+  user_agent: "${user_agent}"
+
+  # Modo verbose para debugging
+  verbose: ${verbose}
+
+# Configuración de servicios
+# Define cada servicio a testear
+services:
+${services_config}

socialseed_e2e/templates/service_page.py.template

@@ -0,0 +1,83 @@
+"""Página de servicio para ${service_name}.
+
+Este módulo define la clase de página para interactuar con el servicio ${service_name}.
+"""
+
+from typing import Optional
+from playwright.sync_api import APIResponse
+
+from socialseed_e2e.core.base_page import BasePage
+
+
+class ${class_name}Page(BasePage):
+    """Página de servicio para ${service_name}.
+
+    Gestiona el estado compartido entre módulos de test.
+
+    Attributes:
+        current_entity: Entidad actualmente seleccionada
+        auth_token: Token de autenticación
+    """
+
+    def __init__(self, playwright=None, base_url: Optional[str] = None):
+        """Inicializa la página de servicio.
+
+        Args:
+            playwright: Instancia de Playwright
+            base_url: URL base del servicio (opcional)
+        """
+        # Cargar configuración desde e2e.conf
+        from .config import get_${snake_case_name}_config
+        config = get_${snake_case_name}_config()
+
+        url = base_url or config.base_url
+        super().__init__(url, playwright, default_headers=config.default_headers)
+
+        # Estado compartido entre módulos
+        self.current_entity: Optional[dict] = None
+        self.auth_token: Optional[str] = None
+
+    def get_entity(self, entity_id: str) -> APIResponse:
+        """Obtener entidad por ID.
+
+        Args:
+            entity_id: ID de la entidad
+
+        Returns:
+            APIResponse: Respuesta HTTP
+        """
+        return self.get(f"/${endpoint_prefix}/{entity_id}")
+
+    def create_entity(self, data: dict) -> APIResponse:
+        """Crear nueva entidad.
+
+        Args:
+            data: Datos de la entidad a crear
+
+        Returns:
+            APIResponse: Respuesta HTTP
+        """
+        return self.post("/${endpoint_prefix}", json=data)
+
+    def update_entity(self, entity_id: str, data: dict) -> APIResponse:
+        """Actualizar entidad existente.
+
+        Args:
+            entity_id: ID de la entidad
+            data: Datos a actualizar
+
+        Returns:
+            APIResponse: Respuesta HTTP
+        """
+        return self.put(f"/${endpoint_prefix}/{entity_id}", json=data)
+
+    def delete_entity(self, entity_id: str) -> APIResponse:
+        """Eliminar entidad.
+
+        Args:
+            entity_id: ID de la entidad
+
+        Returns:
+            APIResponse: Respuesta HTTP
+        """
+        return self.delete(f"/${endpoint_prefix}/{entity_id}")

socialseed_e2e/templates/test_module.py.template

@@ -0,0 +1,46 @@
+"""Test module for ${test_name} flow.
+
+This module implements the test flow for ${test_description}.
+"""
+
+from playwright.sync_api import APIResponse
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..${snake_case_service}_page import ${class_name}Page
+
+
+def run(${snake_case_service}: '${class_name}Page') -> APIResponse:
+    """Execute ${test_name} test flow.
+
+    This test validates the ${test_description} functionality.
+
+    Args:
+        ${snake_case_service}: Instance of ${class_name}Page
+
+    Returns:
+        APIResponse: HTTP response from the API
+
+    Raises:
+        AssertionError: If test assertions fail
+    """
+    print(f"Running ${test_name} test...")
+
+    # Arrange: Setup test data and preconditions
+    # TODO: Add test data setup here
+
+    # Act: Execute the operation being tested
+    # TODO: Add API call here
+    # response = ${snake_case_service}.get("/${endpoint}")
+
+    # Assert: Verify the results
+    # TODO: Add assertions here
+    # assert response.ok, f"Expected success, got {response.status}"
+    # data = response.json()
+    # assert "expected_field" in data
+
+    # Store state for subsequent tests (optional)
+    # ${snake_case_service}.current_entity = data
+
+    print(f"✓ ${test_name} test completed successfully")
+    return response

socialseed_e2e/utils/__init__.py

@@ -0,0 +1,44 @@
+"""Utility functions for socialseed-e2e."""
+
+from .template_engine import TemplateEngine, to_camel_case, to_class_name, to_snake_case
+from .validators import (
+    ValidationError,
+    validate_base_url,
+    validate_dict,
+    validate_email,
+    validate_integer,
+    validate_json_response,
+    validate_list,
+    validate_pagination_response,
+    validate_port,
+    validate_service_name,
+    validate_status_code,
+    validate_string,
+    validate_timeout,
+    validate_url,
+    validate_uuid,
+)
+
+__all__ = [
+    # Template engine
+    "TemplateEngine",
+    "to_class_name",
+    "to_snake_case",
+    "to_camel_case",
+    # Validators
+    "ValidationError",
+    "validate_url",
+    "validate_base_url",
+    "validate_port",
+    "validate_timeout",
+    "validate_service_name",
+    "validate_string",
+    "validate_integer",
+    "validate_email",
+    "validate_uuid",
+    "validate_status_code",
+    "validate_json_response",
+    "validate_pagination_response",
+    "validate_list",
+    "validate_dict",
+]