klab-pytest-toolkit-web 0.0.0__py3-none-any.whl

klab_pytest_toolkit_web/__init__.py

@@ -0,0 +1,28 @@
+"""Klab Pytest Toolkit - Web Fixtures"""
+
+from klab_pytest_toolkit_web.validators import (
+    JsonResponseValidator,
+    ResponseValidatorFactory,
+)
+
+from klab_pytest_toolkit_web.api_client import ApiClientFactory
+
+from klab_pytest_toolkit_web.web_client import (
+    WebClientFactory,
+    WebClient,
+)
+
+from klab_pytest_toolkit_web._api_client_types.grpc_client import GrpcClient
+from klab_pytest_toolkit_web._api_client_types.rest_client import RestApiClient
+
+__version__ = "0.0.0"
+
+__all__ = [
+    "JsonResponseValidator",
+    "ResponseValidatorFactory",
+    "RestApiClient",
+    "GrpcClient",
+    "ApiClientFactory",
+    "WebClient",
+    "WebClientFactory",
+]

klab_pytest_toolkit_web/_api_client_types/__init__.py

@@ -0,0 +1,22 @@
+"""API client types for the klab-pytest-toolkit-web package."""
+
+import abc
+
+
+class ApiClient(abc.ABC):
+    """Abstract base class for API clients."""
+
+    def close(self) -> None:
+        """Close any resources held by the client."""
+        raise NotImplementedError
+
+    def __enter__(self):
+        """Enter the runtime context related to this object."""
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Exit the runtime context related to this object."""
+        self.close()
+
+
+__all__ = ["ApiClient"]

klab_pytest_toolkit_web/_api_client_types/grpc_client.py

@@ -0,0 +1,229 @@
+import grpc
+from typing import Optional, Any, List, Tuple, Callable, Dict
+from pathlib import Path
+import importlib.util
+import tempfile
+import sys
+from grpc_tools import protoc
+from klab_pytest_toolkit_web._api_client_types import ApiClient
+
+
+class GrpcClient(ApiClient):
+    """
+    gRPC client with dynamic method binding.
+
+    Supports proto file loading for service discovery.
+    Methods are dynamically bound to the client instance for easy access.
+
+    Examples:
+        client = GrpcClient(
+            target="localhost:50051",
+            proto_file="service.proto"
+        )
+        response = client.call("SayHello", name="World")
+        # or
+        response = client.SayHello(name="World")
+    """
+
+    def __init__(
+        self,
+        target: str,
+        proto_file: str,
+        credentials: Optional[grpc.ChannelCredentials] = None,
+        options: Optional[List[Tuple[str, Any]]] = None,
+        metadata: Optional[List[Tuple[str, str]]] = None,
+    ):
+        self.target = target
+        self.metadata = metadata or []
+        self._stubs: Dict[str, Any] = {}
+        self._methods: Dict[str, Any] = {}
+        self._request_classes: Dict[str, Any] = {}
+        self._channel = None
+        self._temp_dir = None  # Keep temp dir alive!
+
+        # Create channel
+        if credentials:
+            self._channel = grpc.secure_channel(target, credentials, options=options)
+        else:
+            self._channel = grpc.insecure_channel(target, options=options)
+
+        # Load service definitions from proto file
+        self._load_from_proto(proto_file)
+
+    def _load_from_proto(self, proto_file: str) -> None:
+        """Load service definition from proto file."""
+        proto_path = Path(proto_file)
+        if not proto_path.exists():
+            raise FileNotFoundError(f"Proto file not found: {proto_file}")
+
+        # Keep temp directory alive for the lifetime of the client
+        self._temp_dir = tempfile.TemporaryDirectory()
+        temp_path = Path(self._temp_dir.name)
+
+        # Compile proto file
+        result = protoc.main(
+            [
+                "grpc_tools.protoc",
+                f"--proto_path={proto_path.parent}",
+                f"--python_out={temp_path}",
+                f"--grpc_python_out={temp_path}",
+                proto_path.name,
+            ]
+        )
+
+        if result != 0:
+            raise RuntimeError(f"Proto compilation failed with exit code: {result}")
+
+        # Load generated modules
+        proto_name = proto_path.stem
+        pb2_file = temp_path / f"{proto_name}_pb2.py"
+        grpc_file = temp_path / f"{proto_name}_pb2_grpc.py"
+
+        spec_pb2 = importlib.util.spec_from_file_location(f"{proto_name}_pb2", pb2_file)
+        spec_grpc = importlib.util.spec_from_file_location(f"{proto_name}_pb2_grpc", grpc_file)
+
+        if not spec_pb2 or not spec_grpc:
+            raise RuntimeError("Failed to load generated proto modules")
+
+        pb2_module = importlib.util.module_from_spec(spec_pb2)
+        grpc_module = importlib.util.module_from_spec(spec_grpc)
+
+        sys.modules[f"{proto_name}_pb2"] = pb2_module
+        sys.modules[f"{proto_name}_pb2_grpc"] = grpc_module
+
+        if spec_pb2.loader and spec_grpc.loader:
+            spec_pb2.loader.exec_module(pb2_module)
+            spec_grpc.loader.exec_module(grpc_module)
+        else:
+            raise RuntimeError("Failed to load proto module loaders")
+
+        # Register services
+        self._register_services(pb2_module, grpc_module)
+
+    def _register_services(self, pb2_module: Any, grpc_module: Any) -> None:
+        """Register services from compiled proto modules."""
+
+        method_to_request_class: Dict[str, Any] = {}
+
+        descriptor = pb2_module.DESCRIPTOR
+        for service_name, service_desc in descriptor.services_by_name.items():
+            for method in service_desc.methods:
+                # Get the request class name from the descriptor
+                request_class_name = method.input_type.name
+                request_class = getattr(pb2_module, request_class_name)
+                method_to_request_class[method.name] = request_class
+
+        # Find and instantiate stub classes
+        for name in dir(grpc_module):
+            if name.endswith("Stub") and not name.startswith("_"):
+                stub_class = getattr(grpc_module, name)
+                service_name = name[:-4]  # Remove "Stub" suffix
+
+                stub = stub_class(self._channel)
+                self._stubs[service_name] = stub
+
+                # Register methods
+                for method_name in dir(stub):
+                    if not method_name.startswith("_"):
+                        method = getattr(stub, method_name)
+                        if callable(method):
+                            self._methods[method_name] = method
+
+                            # Use the descriptor-based mapping
+                            if method_name in method_to_request_class:
+                                self._request_classes[method_name] = method_to_request_class[
+                                    method_name
+                                ]
+                            else:
+                                print(f"  Warning: No request class found for {method_name}")
+
+                            # Pre-bind method
+                            setattr(
+                                self,
+                                method_name,
+                                self._create_method_wrapper(method_name, method),
+                            )
+
+    def call(self, method_name: str, request_dict: Optional[dict] = None, **kwargs) -> Any:
+        """
+        Call a gRPC method by name with parameters.
+
+        Args:
+            method_name: Name of the gRPC method to call
+            request_dict: Optional dictionary of request parameters
+            **kwargs: Request parameters as keyword arguments
+
+        Returns:
+            The response from the gRPC method
+
+        Examples:
+            response = client.call("SayHello", name="World")
+            response = client.call("SayHello", {"name": "World"})
+        """
+        if method_name not in self._methods:
+            from difflib import get_close_matches
+
+            suggestions = get_close_matches(method_name, self._methods.keys(), n=3, cutoff=0.6)
+            suggestion_text = f" Did you mean: {', '.join(suggestions)}?" if suggestions else ""
+            raise AttributeError(
+                f"Method '{method_name}' not found.{suggestion_text} "
+                f"Available methods: {list(self._methods.keys())}"
+            )
+
+        params = {**(request_dict or {}), **kwargs}
+        grpc_method = self._methods[method_name]
+        request_class = self._request_classes[method_name]
+
+        try:
+            request = request_class(**params)
+            return grpc_method(request, metadata=self.metadata)
+        except grpc.RpcError as e:
+            details = e.details() if hasattr(e, "details") and callable(e.details) else str(e)
+            raise RuntimeError(f"gRPC call to {method_name} failed: {details}") from e
+        except Exception as e:
+            raise RuntimeError(f"Error calling {method_name}: {str(e)}") from e
+
+    def _create_method_wrapper(self, method_name: str, grpc_method: Any) -> Callable[..., Any]:
+        """Create a wrapper for gRPC method that delegates to call()."""
+
+        def wrapper(*args, **kwargs):
+            if args:
+                if len(args) > 1:
+                    raise ValueError(f"Expected 0 or 1 positional arguments, got {len(args)}")
+                request = args[0]
+                try:
+                    return grpc_method(request, metadata=self.metadata)
+                except grpc.RpcError as e:
+                    details = (
+                        e.details() if hasattr(e, "details") and callable(e.details) else str(e)
+                    )
+                    raise RuntimeError(f"gRPC call to {method_name} failed: {details}") from e
+            else:
+                return self.call(method_name, **kwargs)
+
+        wrapper.__name__ = method_name
+        return wrapper
+
+    def get_available_methods(self) -> List[str]:
+        """Get list of available RPC methods."""
+        return list(self._methods.keys())
+
+    def get_request_class(self, method_name: str) -> Any:
+        """Get the request class for a method."""
+        return self._request_classes.get(method_name)
+
+    def close(self) -> None:
+        """Close the gRPC channel and cleanup."""
+        if self._channel:
+            self._channel.close()
+            self._channel = None
+        if self._temp_dir:
+            self._temp_dir.cleanup()
+            self._temp_dir = None
+
+    def __del__(self):
+        self.close()
+
+    def __repr__(self) -> str:
+        methods = ", ".join(self._methods.keys()) if self._methods else "No methods loaded"
+        return f"<GrpcClient(target='{self.target}', methods=[{methods}])>"

klab_pytest_toolkit_web/_api_client_types/rest_client.py

@@ -0,0 +1,147 @@
+from typing import Any, Dict, Optional
+from klab_pytest_toolkit_web._api_client_types import ApiClient
+import requests
+
+
+class RestApiClient(ApiClient):
+    def __init__(
+        self,
+        base_url: str,
+        headers: Optional[Dict[str, str]] = None,
+    ):
+        """
+        Initialize REST API client.
+
+        Args:
+            base_url: Base URL for API requests
+            headers: Optional default headers for all requests
+        """
+        self.base_url = base_url
+        self.headers = headers or {}
+        self.session = requests.Session()
+
+    def get(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        timeout: Optional[int] = None,
+    ) -> requests.Response:
+        """
+        Make a GET request.
+
+        Args:
+            endpoint: API endpoint path
+            params: Optional query parameters
+            timeout: Optional timeout in seconds for this request
+
+        Returns:
+            Response object
+        """
+        url = f"{self.base_url}{endpoint}"
+        return self.session.get(
+            url,
+            params=params,
+            headers=self.headers,
+            timeout=timeout,
+        )
+
+    def post(
+        self,
+        endpoint: str,
+        payload: Optional[Dict[str, Any]] = None,
+        timeout: Optional[int] = None,
+    ) -> requests.Response:
+        """
+        Make a POST request.
+
+        Args:
+            endpoint: API endpoint path
+            payload: Optional JSON payload
+            timeout: Optional timeout in seconds for this request
+
+        Returns:
+            Response object
+        """
+        url = f"{self.base_url}{endpoint}"
+        return self.session.post(
+            url,
+            json=payload,
+            headers=self.headers,
+            timeout=timeout,
+        )
+
+    def put(
+        self,
+        endpoint: str,
+        payload: Optional[Dict[str, Any]] = None,
+        timeout: Optional[int] = None,
+    ) -> requests.Response:
+        """
+        Make a PUT request.
+
+        Args:
+            endpoint: API endpoint path
+            payload: Optional JSON payload
+            timeout: Optional timeout in seconds for this request
+
+        Returns:
+            Response object
+        """
+        url = f"{self.base_url}{endpoint}"
+        return self.session.put(
+            url,
+            json=payload,
+            headers=self.headers,
+            timeout=timeout,
+        )
+
+    def patch(
+        self,
+        endpoint: str,
+        payload: Optional[Dict[str, Any]] = None,
+        timeout: Optional[int] = None,
+    ) -> requests.Response:
+        """
+        Make a PATCH request.
+
+        Args:
+            endpoint: API endpoint path
+            payload: Optional JSON payload
+            timeout: Optional timeout in seconds for this request
+
+        Returns:
+            Response object
+        """
+        url = f"{self.base_url}{endpoint}"
+        return self.session.patch(
+            url,
+            json=payload,
+            headers=self.headers,
+            timeout=timeout,
+        )
+
+    def delete(
+        self,
+        endpoint: str,
+        timeout: Optional[int] = None,
+    ) -> requests.Response:
+        """
+        Make a DELETE request.
+
+        Args:
+            endpoint: API endpoint path
+            timeout: Optional timeout in seconds for this request
+
+        Returns:
+            Response object
+        """
+        url = f"{self.base_url}{endpoint}"
+        return self.session.delete(
+            url,
+            headers=self.headers,
+            timeout=timeout,
+        )
+
+    def close(self) -> None:
+        """Close the session."""
+        self.session.close()

klab_pytest_toolkit_web/api_client.py

@@ -0,0 +1,83 @@
+import grpc
+from klab_pytest_toolkit_web._api_client_types.rest_client import RestApiClient
+from typing import Dict, Any, Optional, List, Tuple
+from klab_pytest_toolkit_web._api_client_types.grpc_client import GrpcClient
+
+
+class ApiClientFactory:
+    def create_rest_client(
+        self,
+        base_url: str,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> RestApiClient:
+        """
+        Create a REST API client instance.
+
+        Args:
+            base_url: Base URL for API requests
+            headers: Optional default headers
+
+        Returns:
+            RestApiClient instance
+
+        Example:
+            >>> factory = ApiClientFactory()
+            >>> client = factory.create_rest_client(
+            ...     base_url="https://api.example.com",
+            ...     headers={"Authorization": "Bearer token"}
+            ... )
+            >>> response = client.get("/users/1")
+            >>> # Set timeout per request when needed
+            >>> response = client.get("/slow-endpoint", timeout=120)
+        """
+        return RestApiClient(base_url=base_url, headers=headers)
+
+    def create_grpc_client(
+        self,
+        target: str,
+        proto_file: str,
+        credentials: Optional[grpc.ChannelCredentials] = None,
+        options: Optional[List[Tuple[str, Any]]] = None,
+        metadata: Optional[List[Tuple[str, str]]] = None,
+    ) -> GrpcClient:
+        """
+        Create a gRPC client instance with dynamic method binding.
+
+        Args:
+            target: gRPC server address (e.g., "localhost:50051")
+            proto_file: Path to .proto file for service definition
+            credentials: Optional channel credentials for secure connection
+            options: Optional channel options (e.g., [('grpc.max_receive_message_length', -1)])
+            metadata: Optional metadata to send with each request
+
+        Returns:
+            GrpcClient instance with dynamically bound methods
+
+        Raises:
+            ValueError: If neither proto_file nor use_reflection is provided
+
+        Example:
+            >>> # Using proto file
+            >>> factory = ApiClientFactory()
+            >>> client = factory.create_grpc_client(
+            ...     target="localhost:50051",
+            ...     proto_file="path/to/service.proto"
+            ... )
+            >>> response = client.GetUser(id=123)
+            >>>
+            >>> # With SSL/TLS
+            >>> creds = grpc.ssl_channel_credentials()
+            >>> client = factory.create_grpc_client(
+            ...     target="secure.example.com:443",
+            ...     proto_file="service.proto",
+            ...     credentials=creds
+            ... )
+        """
+
+        return GrpcClient(
+            target=target,
+            proto_file=proto_file,
+            credentials=credentials,
+            options=options,
+            metadata=metadata,
+        )

klab_pytest_toolkit_web/plugin.py

@@ -0,0 +1,62 @@
+"""Pytest plugin to register web fixtures."""
+
+import pytest
+from klab_pytest_toolkit_web import (
+    ApiClientFactory,
+    ResponseValidatorFactory,
+    WebClientFactory,
+)
+
+
+def pytest_configure(config):
+    """Register custom markers and configure web fixtures."""
+    pass
+
+
+def pytest_addoption(parser):
+    """Add command line and ini file options."""
+    pass
+
+
+@pytest.fixture
+def response_validator_factory() -> ResponseValidatorFactory:
+    """
+    Factory fixture to create multiple validators with different schemas.
+
+    Useful when you need multiple validators in a single test.
+
+    Example:
+        def test_multiple_schemas(response_validator_factory: JsonResponseValidatorFactory):
+            user_validator = response_validator_factory.create(user_schema)
+            post_validator = response_validator_factory.create(post_schema)
+
+            assert user_validator.validate_response(user_data)
+            assert post_validator.validate_response(post_data)
+
+    Returns:
+        JsonResponseValidatorFactory: Factory to create JsonResponseValidator instances
+    """
+
+    return ResponseValidatorFactory()
+
+
+@pytest.fixture
+def api_client_factory() -> ApiClientFactory:
+    """
+    Fixture to provide an API client factory for making web requests.
+
+    Returns:
+        ApiClientFactory: Factory to create API client instances
+    """
+    return ApiClientFactory()
+
+
+@pytest.fixture
+def web_client_factory() -> WebClientFactory:
+    """
+    Fixture to provide a Web client factory for making web requests.
+
+    Returns:
+        WebClientFactory: Factory to create Web client instances
+    """
+    return WebClientFactory()

klab_pytest_toolkit_web/validators.py

@@ -0,0 +1,88 @@
+from typing import Dict, Any, Optional
+from jsonschema import validate, ValidationError
+from jsonschema.exceptions import SchemaError
+
+
+class JsonResponseValidator:
+    """Validator for JSON responses with schema validation and additional checks."""
+
+    def __init__(
+        self,
+        schema: Optional[Dict[str, Any]] = None,
+        raise_on_error: Optional[bool] = None,
+    ):
+        """
+        Initialize the JSON response validator.
+
+        Args:
+            schema: JSON schema to validate against (can be set later)
+            strict_mode: If True, disallow additional properties not in schema
+            raise_on_error: If True, raise ValidationError instead of returning False
+        """
+        self.schema = schema
+        self.raise_on_error = raise_on_error
+        self.last_error: Optional[str] = None
+
+    def validate_response(self, response_data: Dict[str, Any]) -> bool:
+        """
+        Validate response data against the schema.
+
+        Args:
+            response_data: The JSON response data to validate
+
+        Returns:
+            True if valid, False otherwise (unless raise_on_error=True)
+
+        Raises:
+            ValidationError: If raise_on_error=True and validation fails
+            ValueError: If no schema is set
+        """
+        if self.schema is None:
+            raise ValueError("No schema set for validation")
+
+        try:
+            validate(instance=response_data, schema=self.schema)
+            self.last_error = None
+            return True
+        except ValidationError as e:
+            self.last_error = str(e)
+            if self.raise_on_error:
+                raise
+            return False
+        except SchemaError as e:
+            self.last_error = f"Invalid schema: {str(e)}"
+            if self.raise_on_error:
+                raise
+            return False
+
+    def get_last_error(self) -> str:
+        """Get the last validation error message."""
+        if self.last_error is None:
+            return ""
+
+        return self.last_error
+
+
+class ResponseValidatorFactory:
+    """Factory to create different Response Validators instances with different configurations."""
+
+    def create_json_validator(
+        self,
+        schema: Optional[Dict[str, Any]] = None,
+        raise_on_error: Optional[bool] = None,
+    ) -> JsonResponseValidator:
+        """
+        Create a new JsonResponseValidator instance.
+
+        Args:
+            schema: JSON schema for the validator
+            strict_mode: Override default strict mode
+            raise_on_error: Override default error handling
+
+        Returns:
+            JsonResponseValidator: Configured validator instance
+        """
+        return JsonResponseValidator(
+            schema=schema,
+            raise_on_error=raise_on_error,
+        )

klab_pytest_toolkit_web/web_client.py

@@ -0,0 +1,360 @@
+import abc
+from typing import Optional
+
+
+class WebClient(abc.ABC):
+    """A simple web client is a class which can test websites by making
+    - searching element and clicking
+    - filling forms
+    - navigating pages
+    - checks if page contains some text or elements
+
+    This is an abstract base class that defines the interface for web clients.
+    Implementations should provide browser automation capabilities for e2e testing.
+    """
+
+    @abc.abstractmethod
+    def navigate_to(self, url: str) -> None:
+        """Navigate to a specified URL.
+
+        Args:
+            url: The URL to navigate to
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def click(self, selector: str) -> None:
+        """Click on an element identified by a selector.
+
+        Args:
+            selector: CSS selector, XPath, or text selector to identify the element
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def fill(self, selector: str, value: str) -> None:
+        """Fill a form field with a value.
+
+        Args:
+            selector: CSS selector, XPath, or text selector to identify the input element
+            value: The value to fill into the field
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_text(self, selector: str) -> str:
+        """Get the text content of an element.
+
+        Args:
+            selector: CSS selector, XPath, or text selector to identify the element
+
+        Returns:
+            The text content of the element
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_attribute(self, selector: str, attribute: str) -> Optional[str]:
+        """Get an attribute value of an element.
+
+        Args:
+            selector: CSS selector, XPath, or text selector to identify the element
+            attribute: The name of the attribute to retrieve
+
+        Returns:
+            The attribute value or None if not found
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_input_value(self, selector: str) -> str:
+        """Get the current value of an input element.
+
+        Args:
+            selector: CSS selector to identify the input element
+
+        Returns:
+            The current value of the input
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def is_checked(self, selector: str) -> bool:
+        """Check if a checkbox or radio button is checked.
+
+        Args:
+            selector: CSS selector to identify the checkbox/radio element
+
+        Returns:
+            True if checked, False otherwise
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def is_visible(self, selector: str) -> bool:
+        """Check if an element is visible on the page.
+
+        Args:
+            selector: CSS selector, XPath, or text selector to identify the element
+
+        Returns:
+            True if the element is visible, False otherwise
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def is_enabled(self, selector: str) -> bool:
+        """Check if an element is enabled (not disabled).
+
+        Args:
+            selector: CSS selector, XPath, or text selector to identify the element
+
+        Returns:
+            True if the element is enabled, False otherwise
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def wait_for_element(self, selector: str, timeout: int = 30000) -> None:
+        """Wait for an element to be present in the DOM.
+
+        Args:
+            selector: CSS selector, XPath, or text selector to identify the element
+            timeout: Maximum time to wait in milliseconds (default: 30000)
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def wait_for_element_visible(self, selector: str, timeout: int = 30000) -> None:
+        """Wait for an element to be visible on the page.
+
+        Args:
+            selector: CSS selector, XPath, or text selector to identify the element
+            timeout: Maximum time to wait in milliseconds (default: 30000)
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_title(self) -> str:
+        """Get the page title.
+
+        Returns:
+            The title of the current page
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_url(self) -> str:
+        """Get the current page URL.
+
+        Returns:
+            The current URL
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_page_source(self) -> str:
+        """Get the HTML source of the current page.
+
+        Returns:
+            The HTML source as a string
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def contains_text(self, text: str) -> bool:
+        """Check if the page contains the specified text.
+
+        Args:
+            text: The text to search for
+
+        Returns:
+            True if the text is found, False otherwise
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_elements_count(self, selector: str) -> int:
+        """Get the count of elements matching the selector.
+
+        Args:
+            selector: CSS selector, XPath, or text selector to identify the elements
+
+        Returns:
+            The number of matching elements
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def select_option(self, selector: str, value: str) -> None:
+        """Select an option from a dropdown/select element.
+
+        Args:
+            selector: CSS selector to identify the select element
+            value: The value of the option to select
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def check(self, selector: str) -> None:
+        """Check a checkbox or radio button.
+
+        Args:
+            selector: CSS selector to identify the checkbox/radio element
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def uncheck(self, selector: str) -> None:
+        """Uncheck a checkbox.
+
+        Args:
+            selector: CSS selector to identify the checkbox element
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def screenshot(self, path: str) -> None:
+        """Take a screenshot of the current page.
+
+        Args:
+            path: File path where the screenshot should be saved
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def close(self) -> None:
+        """Close the browser and clean up resources."""
+        raise NotImplementedError
+
+    def __enter__(self) -> "WebClient":
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit - ensures cleanup."""
+        self.close()
+
+
+class PlayWrightWebClient(WebClient):
+    """A web client implementation using Playwright."""
+
+    def __init__(self, headless: bool = True):
+        """Initialize Playwright web client.
+
+        Args:
+            headless: Whether to run the browser in headless mode (default: True)
+        """
+        from playwright.sync_api import sync_playwright
+
+        self._playwright = sync_playwright().start()
+        self._browser = self._playwright.chromium.launch(headless=headless)
+        self._page = self._browser.new_page()
+
+    def navigate_to(self, url: str) -> None:
+        """Navigate to a specified URL."""
+        self._page.goto(url)
+
+    def click(self, selector: str) -> None:
+        """Click on an element identified by a selector."""
+        self._page.click(selector)
+
+    def fill(self, selector: str, value: str) -> None:
+        """Fill a form field with a value."""
+        self._page.fill(selector, value)
+
+    def get_text(self, selector: str) -> str:
+        """Get the text content of an element."""
+        return self._page.text_content(selector) or ""
+
+    def get_attribute(self, selector: str, attribute: str) -> Optional[str]:
+        """Get an attribute value of an element."""
+        return self._page.get_attribute(selector, attribute)
+
+    def get_input_value(self, selector: str) -> str:
+        """Get the current value of an input element."""
+        return self._page.input_value(selector)
+
+    def is_checked(self, selector: str) -> bool:
+        """Check if a checkbox or radio button is checked."""
+        return self._page.is_checked(selector)
+
+    def is_visible(self, selector: str) -> bool:
+        """Check if an element is visible on the page."""
+        return self._page.is_visible(selector)
+
+    def is_enabled(self, selector: str) -> bool:
+        """Check if an element is enabled (not disabled)."""
+        return self._page.is_enabled(selector)
+
+    def wait_for_element(self, selector: str, timeout: int = 30000) -> None:
+        """Wait for an element to be present in the DOM."""
+        self._page.wait_for_selector(selector, timeout=timeout)
+
+    def wait_for_element_visible(self, selector: str, timeout: int = 30000) -> None:
+        """Wait for an element to be visible on the page."""
+        self._page.wait_for_selector(selector, state="visible", timeout=timeout)
+
+    def get_title(self) -> str:
+        """Get the page title."""
+        return self._page.title()
+
+    def get_url(self) -> str:
+        """Get the current page URL."""
+        return self._page.url
+
+    def get_page_source(self) -> str:
+        """Get the HTML source of the current page."""
+        return self._page.content()
+
+    def contains_text(self, text: str) -> bool:
+        """Check if the page contains the specified text."""
+        return text in self._page.content()
+
+    def get_elements_count(self, selector: str) -> int:
+        """Get the count of elements matching the selector."""
+        return len(self._page.query_selector_all(selector))
+
+    def select_option(self, selector: str, value: str) -> None:
+        """Select an option from a dropdown/select element."""
+        self._page.select_option(selector, value)
+
+    def check(self, selector: str) -> None:
+        """Check a checkbox or radio button."""
+        self._page.check(selector)
+
+    def uncheck(self, selector: str) -> None:
+        """Uncheck a checkbox."""
+        self._page.uncheck(selector)
+
+    def screenshot(self, path: str) -> None:
+        """Take a screenshot of the current page."""
+        self._page.screenshot(path=path)
+
+    def close(self) -> None:
+        """Close the browser and Playwright."""
+        self._browser.close()
+        self._playwright.stop()
+
+
+class WebClientFactory:
+    """Factory to create web client instances."""
+
+    class WebClientType:
+        PLAYWRIGHT = "playwright"
+
+    @staticmethod
+    def create_client(client_type: str = "playwright", headless: bool = True) -> WebClient:
+        """Create a web client based on the specified type.
+
+        Args:
+            client_type: Type of web client to create (e.g., "playwright")
+            headless: Whether to run the browser in headless mode (default: True)
+
+        Returns:
+            An instance of WebClient
+        """
+        if client_type == WebClientFactory.WebClientType.PLAYWRIGHT:
+            return PlayWrightWebClient(headless=headless)
+        else:
+            raise ValueError(f"Unsupported client type: {client_type}")

klab_pytest_toolkit_web-0.0.0.dist-info/METADATA

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: klab-pytest-toolkit-web
+Version: 0.0.0
+Summary: Pytest web fixtures for the Klab Pytest Toolkit
+Project-URL: Changelog, https://github.com/klab365/klab-pytest-toolkit/blob/main/CHANGELOG.md
+Project-URL: Repository, https://github.com/klab365/klab-pytest-toolkit
+Project-URL: Issues, https://github.com/klab365/klab-pytest-toolkit/issues
+Author-email: Burak Kizilkaya <burak.kizilkaya@outlook.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: <4,>=3.11
+Requires-Dist: grpcio-reflection>=1.66.0
+Requires-Dist: grpcio-tools>=1.66.0
+Requires-Dist: grpcio>=1.66.0
+Requires-Dist: jsonschema>=4.25.1
+Requires-Dist: playwright>=1.57.0
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: requests>=2.32.5
+Description-Content-Type: text/markdown
+
+# Klab Pytest Toolkit - Web Fixtures
+
+Custom pytest fixtures for web testing.
+The goal is to allow testers to easily test web applications (html/json/rest api) with reusable components.
+
+At the moment the package provides the following fixtures:
+
+- `response_validator_factory`: Factory for create JSON response validator instances with custom configurations.
+- `api_client_factory`: Factory for create different API client instances.
+  - REST API client for making HTTP requests to RESTful services.
+- `web_client_factory`: Factory to create web client instances for browser automation
+  - Playwright-based web client for end-to-end testing of web applications.
+
+## Installation
+
+```bash
+pip install klab-pytest-toolkit-web
+```
+
+## Usage
+
+### JSON Response Validator
+
+**Create the fixture**
+
+The factory class `ResponseValidatorFactory` is already provided as a pytest fixture `response_validator_factory`.
+
+```python
+@pytest.fixture
+def json_validator_user_schema(response_validator_factory) -> JsonResponseValidator:
+    """Fixture to provide a JSON response validator for user schema."""
+    user_schema = {
+        "type": "object",
+        "properties": {
+            "id": {"type": "integer"},
+            "name": {"type": "string"},
+        },
+        "required": ["id", "name"]
+    }
+    return response_validator_factory.create_json_validator(schema=user_schema)
+```
+
+**Functions**
+
+The validator contains one main function to validate a response against the schema. Below is an example of how to use the validator in a test.
+
+```python
+def test_user_api(json_validator_user_schema):
+    """Test user API response validation."""
+    response_data = {
+        "id": 1,
+        "name": "John Doe"
+    }
+    assert json_validator_user_schema.validate_response(response_data)
+```
+
+### REST API Client
+
+**Create the fixture**
+
+The factory class `ApiClientFactory` is already provided as a pytest fixture `api_client_factory`.
+To pass the url or other header information, you can pass this as environment variables or configure directly in the fixture.
+Below is an example of creating a REST API client fixture from a testcontainer url.
+
+```python
+
+@pytest.fixture(scope="session")
+def httpbin_container():
+    """Fixture to provide an HTTPBin container for testing."""
+
+    with DockerContainer("kennethreitz/httpbin:latest") as httpbin:
+        httpbin.with_exposed_ports(80)
+        httpbin.waiting_for(HttpWaitStrategy(path="/get", port=80).for_status_code(200))
+        httpbin.start()
+        port = httpbin.get_exposed_port(80)
+        base_url = f"http://localhost:{port}"
+        yield base_url
+
+@pytest.fixture
+def rest_api_client(api_client_factory, httpbin_container) -> RestApiClient:
+    """Fixture to provide a REST API client."""
+    return api_client_factory.create_rest_client(base_url=httpbin_container)
+```
+
+**Functions** 
+
+The REST API client provides functions to make HTTP requests. These are some examples:
+
+```python
+def test_get_request(rest_api_client: RestApiClient):
+    """Test basic GET request with query parameters."""
+    response = rest_api_client.get("/get", params={"test": "value"})
+
+    assert response.status_code == 200
+    json_data = response.json()
+    assert json_data["args"]["test"] == "value"
+
+def test_post_request(rest_api_client: RestApiClient):
+    """Test basic POST request with JSON body."""
+    response = rest_api_client.post("/post", payload={"key": "value"})
+
+    assert response.status_code == 200
+    json_data = response.json()
+    assert json_data["json"]["key"] == "value"
+
+def test_update_request(rest_api_client: RestApiClient):
+    """Test basic PUT request with JSON body."""
+    response = rest_api_client.put("/put", payload={"update": "data"})
+
+    assert response.status_code == 200
+    json_data = response.json()
+    assert json_data["json"]["update"] == "data"
+
+def test_delete_request(rest_api_client: RestApiClient):
+    """Test basic DELETE request."""
+    response = rest_api_client.delete("/delete")
+
+    assert response.status_code == 200
+    json_data = response.json()
+    assert json_data["url"].endswith("/delete")
+```
+
+### gRPC Client
+
+**Create the fixture**
+
+The factory class `ApiClientFactory` is already provided as a pytest fixture `api_client_factory`.
+You can create a gRPC client fixture as shown below:
+
+```python
+@pytest.fixture
+def grpc_client(api_client_factory) -> GrpcClient:
+    """Fixture to provide a gRPC client."""
+    return api_client_factory.create_grpc_client(
+        target="localhost:50051",
+        proto_file="path/to/your/service.proto"
+    )
+```
+
+**Functions**
+
+The `GrpcClient` provides gRPC call functionality by dynamically invoking methods defined in the provided proto file. It is imported the that the proto file defines a service with methods like `GetUser`. You will not get any code completion in your IDE since the methods are dynamically resolved at runtime, but you get error handling if the method does not exist.
+
+```python
+def test_grpc_get_user(grpc_client: GrpcClient):
+    """Test gRPC GetUser call."""
+    response = grpc_client.GetUser(id=123)
+
+    assert response.id == 123
+    assert response.name == "John Doe"
+```
+
+### Playwright Web Client
+
+**Create the fixture**
+
+The factory class `WebClientFactory` is already provided as a pytest fixture `web_client_factory`.
+For playwright, you might install the browsers first by running `playwright install` in your environment.
+You can create a Playwright web client fixture as shown below:
+
+```python
+@pytest.fixture
+def web_client(web_client_factory) -> PlaywrightWebClient:
+    """Fixture to provide a Playwright web client."""
+     with web_client_factory.create_client(client_type="playwright", headless=True) as client:
+        yield client
+```
+
+**Functions**
+
+The `WebClient` provides a variety of functions for browser automation. Refer to the api of the instance.
+Here are some examples of common operations:
+
+```python
+def test_navigate_and_click(web_client):
+    """Test navigation and clicking a button."""
+    web_client.navigate_to("https://example.com")
+    web_client.click("#start-button")
+    assert web_client.get_text("#result") == "Started"
+
+def test_form_submission(web_client):
+    """Test form submission."""
+    web_client.navigate_to("https://example.com/form")
+    web_client.fill_input("#name", "Test User")
+    web_client.fill_input("#email", "max@muster.com")
+    web_client.click("#submit-button")
+    assert web_client.get_text("#confirmation") == "Thank you for your submission!"
+
+def test_wait_for_element(web_client):
+    """Test waiting for an element to appear."""
+    web_client.navigate_to("https://example.com/dynamic")
+    web_client.wait_for_element("#dynamic-content", timeout=10)
+    assert web_client.get_text("#dynamic-content") == "Loaded Content"
+```
+
+## Examples
+
+See the test files for comprehensive examples:
+- `tests/test_jsonvalidator.py` - JSON validation examples covering basic validation, type checking, nested objects, constraints, and error handling
+- `tests/test_restapiclient.py` - REST API client examples with testcontainers integration
+- `tests/test_playwrightclient.py` - Playwright web client examples for browser automation with testcontainers
+
+## Best Practices
+
+### Use Testcontainers for Isolated Environments
+
+When testing web applications, it's recommended to use testcontainers to create isolated environments for your services.
+This ensures that your tests are reproducible and do not interfere with each other.
+
+## License
+
+MIT

klab_pytest_toolkit_web-0.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+klab_pytest_toolkit_web/__init__.py,sha256=9JZoztTOF3lVXzGtlc_CcpCmhHvwginhvJaXLPRrdKo,665
+klab_pytest_toolkit_web/api_client.py,sha256=ConLSFAmHi_32NwkFIFh4JJT5iKVqyBbiM7UGJjlB_s,2874
+klab_pytest_toolkit_web/core.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+klab_pytest_toolkit_web/plugin.py,sha256=tPTAvVe83XOUCCHIpM6D1gNzm8cIFlv8irQJSITlCuM,1646
+klab_pytest_toolkit_web/validators.py,sha256=LpnC--DeWz_GSjKEu1oT3ca0Ce12-VG4wyr8RrMxwY8,2785
+klab_pytest_toolkit_web/web_client.py,sha256=WWXpGyu1kiEkJHy7kTzG3AD_7Njd4vW3M29HlfLNZ-c,11276
+klab_pytest_toolkit_web/_api_client_types/__init__.py,sha256=rvvtKkS8QeXOAwIR5Zva-ecybQhTIVPYH5-PfGFSPJY,546
+klab_pytest_toolkit_web/_api_client_types/grpc_client.py,sha256=5KASvTKcT2AE1jGhnRHZ-7wnm3JCrDSNH7GYOmBWf9Q,8924
+klab_pytest_toolkit_web/_api_client_types/rest_client.py,sha256=4CdHoHRDHIyuYCf41cWVdb81Suy1uF59D3NxA-vL3m4,3667
+klab_pytest_toolkit_web-0.0.0.dist-info/METADATA,sha256=udXvU5VLeA-bmhWvNunfJ4s1Lv_8CY3fV44JpfzPZZs,8430
+klab_pytest_toolkit_web-0.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+klab_pytest_toolkit_web-0.0.0.dist-info/entry_points.txt,sha256=PKiXdDbin0Zp-a4DdI7me4bx1Oqwey2bw3jBzPNsNe0,68
+klab_pytest_toolkit_web-0.0.0.dist-info/RECORD,,

klab_pytest_toolkit_web-0.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

klab_pytest_toolkit_web-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+klab_pytest_toolkit_web = klab_pytest_toolkit_web.plugin