pyrestkit 0.0.0__py3-none-any.whl

pyrestkit/builder/__init__.py

@@ -0,0 +1,5 @@
+from .fluent_request_builder import FluentRequestBuilder
+
+__all__ = [
+    "FluentRequestBuilder",
+]

pyrestkit/builder/fluent_request_builder.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pyrestkit.core.api_client import APIClient
+from pyrestkit.response.framework_response import FrameworkResponse
+
+
+class FluentRequestBuilder:
+    """
+    Fluent API for building and sending HTTP requests.
+
+    Example:
+
+        response = (
+            api.request()
+            .get("/users")
+            .query(page=2)
+            .header("Authorization", token)
+            .send()
+        )
+    """
+
+    def __init__(
+        self,
+        client: APIClient,
+    ) -> None:
+        self._client = client
+
+        self._method = ""
+        self._endpoint = ""
+
+        self._kwargs: dict[str, Any] = {}
+
+    def get(
+        self,
+        endpoint: str,
+    ) -> FluentRequestBuilder:
+        self._method = "GET"
+        self._endpoint = endpoint
+        return self
+
+    def post(
+        self,
+        endpoint: str,
+    ) -> FluentRequestBuilder:
+        self._method = "POST"
+        self._endpoint = endpoint
+        return self
+
+    def put(
+        self,
+        endpoint: str,
+    ) -> FluentRequestBuilder:
+        self._method = "PUT"
+        self._endpoint = endpoint
+        return self
+
+    def patch(
+        self,
+        endpoint: str,
+    ) -> FluentRequestBuilder:
+        self._method = "PATCH"
+        self._endpoint = endpoint
+        return self
+
+    def delete(
+        self,
+        endpoint: str,
+    ) -> FluentRequestBuilder:
+        self._method = "DELETE"
+        self._endpoint = endpoint
+        return self
+
+    def query(
+        self,
+        **params: Any,
+    ) -> FluentRequestBuilder:
+        self._kwargs["params"] = params
+        return self
+
+    def header(
+        self,
+        name: str,
+        value: str,
+    ) -> FluentRequestBuilder:
+        headers = self._kwargs.setdefault(
+            "headers",
+            {},
+        )
+
+        headers[name] = value
+
+        return self
+
+    def headers(
+        self,
+        headers: dict[str, str],
+    ) -> FluentRequestBuilder:
+        current = self._kwargs.setdefault(
+            "headers",
+            {},
+        )
+
+        current.update(headers)
+
+        return self
+
+    def json(
+        self,
+        body: Any,
+    ) -> FluentRequestBuilder:
+        self._kwargs["json"] = body
+        return self
+
+    def data(
+        self,
+        body: Any,
+    ) -> FluentRequestBuilder:
+        self._kwargs["data"] = body
+        return self
+
+    def timeout(
+        self,
+        seconds: int,
+    ) -> FluentRequestBuilder:
+        self._kwargs["timeout"] = seconds
+        return self
+
+    def send(
+        self,
+    ) -> FrameworkResponse:
+        method = self._method.upper()
+
+        if method == "GET":
+            return self._client.get(
+                self._endpoint,
+                **self._kwargs,
+            )
+
+        if method == "POST":
+            return self._client.post(
+                self._endpoint,
+                **self._kwargs,
+            )
+
+        if method == "PUT":
+            return self._client.put(
+                self._endpoint,
+                **self._kwargs,
+            )
+
+        if method == "PATCH":
+            return self._client.patch(
+                self._endpoint,
+                **self._kwargs,
+            )
+
+        if method == "DELETE":
+            return self._client.delete(
+                self._endpoint,
+                **self._kwargs,
+            )
+
+        raise ValueError(
+            "HTTP method not selected.",
+        )

pyrestkit/clients/__init__.py

@@ -0,0 +1,7 @@
+from .base_client import BaseClient
+from .user_client import UserClient
+
+__all__ = [
+    "BaseClient",
+    "UserClient",
+]

pyrestkit/clients/base_client.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pyrestkit.core.api_client import APIClient
+from pyrestkit.response.framework_response import FrameworkResponse
+
+
+class BaseClient:
+    """
+    Base class for all endpoint clients.
+    """
+
+    def __init__(
+        self,
+        api_client: APIClient,
+    ) -> None:
+        self._api_client = api_client
+
+    def get(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        return self._api_client.get(
+            endpoint,
+            **kwargs,
+        )
+
+    def post(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        return self._api_client.post(
+            endpoint,
+            **kwargs,
+        )
+
+    def put(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        return self._api_client.put(
+            endpoint,
+            **kwargs,
+        )
+
+    def patch(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        return self._api_client.patch(
+            endpoint,
+            **kwargs,
+        )
+
+    def delete(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        return self._api_client.delete(
+            endpoint,
+            **kwargs,
+        )

pyrestkit/clients/user_client.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from dataclasses import asdict
+
+from pyrestkit.clients.base_client import BaseClient
+from pyrestkit.core.api_client import APIClient
+from pyrestkit.endpoints.user_endpoints import UserEndpoints
+from pyrestkit.models.request.create_user_request import CreateUserRequest
+from pyrestkit.models.request.update_user_request import UpdateUserRequest
+from pyrestkit.response.framework_response import FrameworkResponse
+
+
+class UserClient(BaseClient):
+    """
+    Business client responsible for User APIs.
+
+    This client delegates HTTP operations to BaseClient.
+    """
+
+    def __init__(
+        self,
+        api_client: APIClient,
+    ) -> None:
+        super().__init__(api_client)
+
+    def list_users(
+        self,
+    ) -> FrameworkResponse:
+        return self.get(
+            UserEndpoints.list_users(),
+        )
+
+    def get_user(
+        self,
+        user_id: int,
+    ) -> FrameworkResponse:
+        return self.get(
+            UserEndpoints.get_user(user_id),
+        )
+
+    def create_user(
+        self,
+        request: CreateUserRequest,
+    ) -> FrameworkResponse:
+        return self.post(
+            UserEndpoints.create_user(),
+            json=asdict(request),
+        )
+
+    def update_user(
+        self,
+        user_id: int,
+        request: UpdateUserRequest,
+    ) -> FrameworkResponse:
+        return self.put(
+            UserEndpoints.update_user(user_id),
+            json=asdict(request),
+        )
+
+    def delete_user(
+        self,
+        user_id: int,
+    ) -> FrameworkResponse:
+        return self.delete(
+            UserEndpoints.delete_user(user_id),
+        )

pyrestkit/config/__init__.py

@@ -0,0 +1,5 @@
+from .config import ConfigManager
+
+__all__ = [
+    "ConfigManager",
+]

pyrestkit/config/config.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, cast
+
+from pyrestkit.exceptions.configuration_exception import ConfigurationException
+
+
+class ConfigManager:
+    """
+    Loads environment configuration from JSON files.
+
+    Why Path(__file__).parent?
+
+    Path(__file__).parent locates the directory containing
+    config.py and appends the selected environment JSON
+    file. This keeps the implementation portable across
+    operating systems.
+
+    Why use @property?
+
+    It allows callers to access configuration values like
+    attributes while keeping the flexibility to validate or
+    compute values internally in the future.
+
+    Why validate the file?
+
+    If a user runs:
+
+        pytest --env=production
+
+    and production.json does not exist, the framework fails
+    immediately with a clear error message.
+    """
+
+    def __init__(
+        self,
+        environment: str = "dev",
+    ) -> None:
+        self.environment = environment.lower()
+
+        config_file = Path(__file__).parent / f"{self.environment}.json"
+
+        if not config_file.exists():
+            raise ConfigurationException(
+                f"Configuration file '{self.environment}' not found.",
+            )
+
+        with config_file.open(
+            encoding="utf-8",
+        ) as file:
+            self.config: dict[str, Any] = json.load(file)
+
+    @property
+    def base_url(self) -> str:
+        return cast(
+            str,
+            self.config["base_url"],
+        )
+
+    @property
+    def timeout(self) -> int:
+        return cast(
+            int,
+            self.config.get(
+                "timeout",
+                30,
+            ),
+        )
+
+    @property
+    def headers(self) -> dict[str, str]:
+        return cast(
+            dict[str, str],
+            self.config.get(
+                "headers",
+                {},
+            ),
+        )
+
+    @property
+    def auto_raise_exceptions(self) -> bool:
+        return cast(
+            bool,
+            self.config.get(
+                "auto_raise_exceptions",
+                True,
+            ),
+        )
+
+    @property
+    def environment_name(self) -> str:
+        return cast(
+            str,
+            self.config["environment"],
+        )

pyrestkit/core/__init__.py

@@ -0,0 +1,13 @@
+from .api_client import APIClient
+from .logger import FrameworkLogger
+from .request_builder import RequestBuilder
+from .request_executor import RequestExecutor
+from .session_manager import SessionManager
+
+__all__ = [
+    "APIClient",
+    "FrameworkLogger",
+    "RequestBuilder",
+    "RequestExecutor",
+    "SessionManager",
+]

pyrestkit/core/api_client.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from pyrestkit.auth.auth_strategy import AuthenticationStrategy
+from pyrestkit.config.config import ConfigManager
+from pyrestkit.core.request_builder import RequestBuilder
+from pyrestkit.core.request_executor import RequestExecutor
+from pyrestkit.core.session_manager import SessionManager
+from pyrestkit.hooks.hook_manager import HookManager
+from pyrestkit.response.framework_response import FrameworkResponse
+
+if TYPE_CHECKING:
+    from pyrestkit.builder.fluent_request_builder import FluentRequestBuilder
+
+
+class APIClient:
+    """
+    Generic HTTP client for the automation framework.
+    """
+
+    def __init__(
+        self,
+        config: ConfigManager,
+        session_manager: SessionManager,
+        auth_strategy: AuthenticationStrategy | None = None,
+        hook_manager: HookManager | None = None,
+    ) -> None:
+        self._builder = RequestBuilder(
+            config=config,
+            auth_strategy=auth_strategy,
+        )
+
+        self._executor = RequestExecutor(
+            config=config,
+            session_manager=session_manager,
+            hook_manager=hook_manager,
+        )
+
+    def request(self) -> FluentRequestBuilder:
+        """
+        Creates a fluent request builder.
+
+        Example:
+
+            response = (
+                api.request()
+                .get("/users")
+                .query(page=2)
+                .send()
+            )
+        """
+        from pyrestkit.builder.fluent_request_builder import (
+            FluentRequestBuilder,
+        )
+
+        return FluentRequestBuilder(self)
+
+    def _send_request(
+        self,
+        method: str,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        url, kwargs = self._builder.build(
+            endpoint,
+            **kwargs,
+        )
+
+        return self._executor.execute(
+            method=method,
+            url=url,
+            **kwargs,
+        )
+
+    def get(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        return self._send_request(
+            "GET",
+            endpoint,
+            **kwargs,
+        )
+
+    def post(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        return self._send_request(
+            "POST",
+            endpoint,
+            **kwargs,
+        )
+
+    def put(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        return self._send_request(
+            "PUT",
+            endpoint,
+            **kwargs,
+        )
+
+    def patch(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        return self._send_request(
+            "PATCH",
+            endpoint,
+            **kwargs,
+        )
+
+    def delete(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        return self._send_request(
+            "DELETE",
+            endpoint,
+            **kwargs,
+        )

pyrestkit/core/logger.py

@@ -0,0 +1,41 @@
+import logging
+from pathlib import Path
+
+
+class FrameworkLogger:
+    """
+    Singleton logger for the automation framework.
+    """
+
+    _logger = None
+
+    @classmethod
+    def get_logger(cls) -> logging.Logger:
+        if cls._logger:
+            return cls._logger
+
+        log_directory = Path("logs")
+        log_directory.mkdir(exist_ok=True)
+
+        log_file = log_directory / "framework.log"
+
+        logger = logging.getLogger("api-framework")
+        logger.setLevel(logging.INFO)
+
+        if logger.handlers:
+            cls._logger = logger
+            return logger
+
+        formatter = logging.Formatter("%(asctime)s | %(levelname)-8s | %(message)s")
+
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+
+        logger.addHandler(file_handler)
+        logger.addHandler(console_handler)
+
+        cls._logger = logger
+        return logger

pyrestkit/core/request_builder.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pyrestkit.auth.auth_strategy import AuthenticationStrategy
+from pyrestkit.config.config import ConfigManager
+
+
+class RequestBuilder:
+    """
+    Builds request arguments for the API client.
+    """
+
+    def __init__(
+        self,
+        config: ConfigManager,
+        auth_strategy: AuthenticationStrategy | None = None,
+    ) -> None:
+        self._config = config
+        self._auth_strategy = auth_strategy
+
+    def build(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> tuple[str, dict[str, Any]]:
+        url = f"{self._config.base_url}{endpoint}"
+
+        headers = self._config.headers.copy()
+
+        if self._auth_strategy is not None:
+            headers.update(self._auth_strategy.get_headers())
+
+        request_headers = kwargs.pop("headers", {})
+        headers.update(request_headers)
+
+        timeout = kwargs.pop(
+            "timeout",
+            self._config.timeout,
+        )
+
+        kwargs["headers"] = headers
+        kwargs["timeout"] = timeout
+
+        return url, kwargs