pyrestkit 1.2.0__py3-none-any.whl

pyrestkit/core/request_executor.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pyrestkit.config.config import ConfigManager
+from pyrestkit.core.logger import FrameworkLogger
+from pyrestkit.core.session_manager import SessionManager
+from pyrestkit.exceptions.exception_mapper import ExceptionMapper
+from pyrestkit.hooks.hook_manager import HookManager
+from pyrestkit.response.framework_response import FrameworkResponse
+
+
+class RequestExecutor:
+    """
+    Executes HTTP requests using the configured session.
+    """
+
+    def __init__(
+        self,
+        config: ConfigManager,
+        session_manager: SessionManager,
+        hook_manager: HookManager | None = None,
+    ) -> None:
+        self._config = config
+        self._session = session_manager.session
+        self._logger = FrameworkLogger.get_logger()
+        self._hook_manager = hook_manager or HookManager()
+
+    def execute(
+        self,
+        method: str,
+        url: str,
+        **kwargs: Any,
+    ) -> FrameworkResponse:
+        self._logger.info(
+            "%s %s",
+            method.upper(),
+            url,
+        )
+
+        self._hook_manager.before_request(
+            method=method,
+            url=url,
+            kwargs=kwargs,
+        )
+
+        response = self._session.request(
+            method=method,
+            url=url,
+            **kwargs,
+        )
+
+        self._hook_manager.after_response(response)
+
+        if self._config.auto_raise_exceptions:
+            ExceptionMapper.raise_for_response(response)
+
+        self._logger.info(
+            "Status Code: %s | Response Time: %.2f ms",
+            response.status_code,
+            response.elapsed.total_seconds() * 1000,
+        )
+
+        return FrameworkResponse(response)

pyrestkit/core/session_manager.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import requests
+
+
+class SessionManager:
+    """
+    Creates and manages HTTP sessions for the framework.
+    """
+
+    def __init__(self) -> None:
+        self._session = requests.Session()
+
+    @property
+    def session(self) -> requests.Session:
+        return self._session
+
+    def close(self) -> None:
+        self._session.close()

pyrestkit/endpoints/__init__.py

@@ -0,0 +1,5 @@
+from .user_endpoints import UserEndpoints
+
+__all__ = [
+    "UserEndpoints",
+]

pyrestkit/endpoints/base_endpoints.py

@@ -0,0 +1,32 @@
+"""
+Base endpoint definitions.
+
+All endpoint classes should inherit from this class.
+"""
+
+
+class BaseEndpoints:
+    """
+    Base class responsible for building API endpoint paths.
+
+    Future enhancements:
+    - API versioning
+    - Service prefixes
+    - Tenant support
+    """
+
+    API_VERSION = ""
+
+    @classmethod
+    def build(cls, path: str) -> str:
+        """
+        Returns complete endpoint path.
+
+        Example:
+            "/users"
+
+        Future:
+            "/api/v1/users"
+        """
+
+        return f"{cls.API_VERSION}{path}"

pyrestkit/endpoints/order_endpoints.py

@@ -0,0 +1,9 @@
+from pyrestkit.endpoints.base_endpoints import BaseEndpoints
+
+"""
+Order endpoint definitions.
+"""
+
+
+class OrderEndpoints(BaseEndpoints):
+    RESOURCE = "/orders"

pyrestkit/endpoints/payment_endpoints.py

@@ -0,0 +1,5 @@
+from pyrestkit.endpoints.base_endpoints import BaseEndpoints
+
+
+class PaymentEndpoints(BaseEndpoints):
+    RESOURCE = "/payments"

pyrestkit/endpoints/user_endpoints.py

@@ -0,0 +1,48 @@
+"""
+User endpoint definitions.
+"""
+
+from pyrestkit.endpoints.base_endpoints import BaseEndpoints
+
+
+class UserEndpoints(BaseEndpoints):
+    """
+    Contains all endpoints related to Users.
+    """
+
+    RESOURCE = "/users"
+
+    @classmethod
+    def list_users(cls) -> str:
+        """
+        GET /users
+        """
+        return cls.build(cls.RESOURCE)
+
+    @classmethod
+    def create_user(cls) -> str:
+        """
+        POST /users
+        """
+        return cls.build(cls.RESOURCE)
+
+    @classmethod
+    def get_user(cls, user_id: int) -> str:
+        """
+        GET /users/{id}
+        """
+        return cls.build(f"{cls.RESOURCE}/{user_id}")
+
+    @classmethod
+    def update_user(cls, user_id: int) -> str:
+        """
+        PUT /users/{id}
+        """
+        return cls.build(f"{cls.RESOURCE}/{user_id}")
+
+    @classmethod
+    def delete_user(cls, user_id: int) -> str:
+        """
+        DELETE /users/{id}
+        """
+        return cls.build(f"{cls.RESOURCE}/{user_id}")

pyrestkit/exceptions/__init__.py

@@ -0,0 +1,21 @@
+"""
+Custom exceptions used throughout the API automation framework.
+"""
+
+from .api_exception import APIException
+from .authentication_exception import AuthenticationException
+from .configuration_exception import ConfigurationException
+from .network_exception import NetworkException
+from .response_exception import ResponseException
+from .serialization_exception import SerializationException
+from .validation_exception import ValidationException
+
+__all__ = [
+    "APIException",
+    "AuthenticationException",
+    "ConfigurationException",
+    "NetworkException",
+    "ResponseException",
+    "SerializationException",
+    "ValidationException",
+]

pyrestkit/exceptions/api_exception.py

@@ -0,0 +1,8 @@
+class APIException(Exception):
+    """
+    Base exception for the API automation framework.
+    """
+
+    def __init__(self, message: str = "") -> None:
+        super().__init__(message)
+        self.message = message

pyrestkit/exceptions/authentication_exception.py

@@ -0,0 +1,10 @@
+from pyrestkit.exceptions.api_exception import APIException
+
+
+class AuthenticationException(APIException):
+    """
+    Raised when authentication fails.
+    """
+
+    def __init__(self, message: str = "Authentication failed.") -> None:
+        super().__init__(message)

pyrestkit/exceptions/configuration_exception.py

@@ -0,0 +1,10 @@
+from pyrestkit.exceptions.api_exception import APIException
+
+
+class ConfigurationException(APIException):
+    """
+    Raised when configuration is invalid.
+    """
+
+    def __init__(self, message: str = "Configuration is invalid.") -> None:
+        super().__init__(message)

pyrestkit/exceptions/exception_mapper.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import requests
+
+from pyrestkit.exceptions.authentication_exception import AuthenticationException
+from pyrestkit.exceptions.response_exception import ResponseException
+from pyrestkit.exceptions.validation_exception import ValidationException
+
+
+class ExceptionMapper:
+    """
+    Maps HTTP status codes to framework exceptions.
+    """
+
+    @staticmethod
+    def raise_for_response(
+        response: requests.Response,
+    ) -> None:
+        status = response.status_code
+
+        if status < 400:
+            return
+
+        if status == 401:
+            raise AuthenticationException("Authentication failed.")
+
+        if status == 422:
+            raise ValidationException("Validation failed.")
+
+        raise ResponseException(
+            f"Request failed with status code {status}.",
+        )

pyrestkit/exceptions/network_exception.py

@@ -0,0 +1,10 @@
+from pyrestkit.exceptions.api_exception import APIException
+
+
+class NetworkException(APIException):
+    """
+    Raised for network related failures.
+    """
+
+    def __init__(self, message: str = "Network error occurred.") -> None:
+        super().__init__(message)

pyrestkit/exceptions/response_exception.py

@@ -0,0 +1,10 @@
+from pyrestkit.exceptions.api_exception import APIException
+
+
+class ResponseException(APIException):
+    """
+    Raised for unexpected HTTP responses.
+    """
+
+    def __init__(self, message: str = "Unexpected response received.") -> None:
+        super().__init__(message)

pyrestkit/exceptions/serialization_exception.py

@@ -0,0 +1,10 @@
+from pyrestkit.exceptions.api_exception import APIException
+
+
+class SerializationException(APIException):
+    """
+    Raised when serialization/deserialization fails.
+    """
+
+    def __init__(self, message: str = "Serialization failed.") -> None:
+        super().__init__(message)

pyrestkit/exceptions/validation_exception.py

@@ -0,0 +1,10 @@
+from pyrestkit.exceptions.api_exception import APIException
+
+
+class ValidationException(APIException):
+    """
+    Raised when response validation fails.
+    """
+
+    def __init__(self, message: str = "Validation failed.") -> None:
+        super().__init__(message)

pyrestkit/factories/__init__.py

@@ -0,0 +1,5 @@
+from .user_factory import UserFactory
+
+__all__ = [
+    "UserFactory",
+]

pyrestkit/factories/base_factory.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, cast
+
+
+class BaseFactory:
+    """
+    Base class for loading test data.
+    """
+
+    TESTDATA_DIR = Path("testdata")
+
+    @classmethod
+    def load_json(
+        cls,
+        filename: str,
+    ) -> dict[str, Any]:
+        file_path = cls.TESTDATA_DIR / filename
+
+        with file_path.open(
+            encoding="utf-8",
+        ) as file:
+            return cast(dict[str, Any], json.load(file))

pyrestkit/factories/user_factory.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import random
+
+from pyrestkit.factories.base_factory import BaseFactory
+from pyrestkit.models.request.create_user_request import CreateUserRequest
+
+
+class UserFactory(BaseFactory):
+    """
+    Factory for CreateUserRequest objects.
+    """
+
+    @classmethod
+    def random(cls) -> CreateUserRequest:
+        return CreateUserRequest(
+            name=f"User-{random.randint(1000, 9999)}",
+            job="QA Engineer",
+        )
+
+    @classmethod
+    def admin(cls) -> CreateUserRequest:
+        return CreateUserRequest(
+            name="Admin User",
+            job="Administrator",
+        )
+
+    @classmethod
+    def from_file(
+        cls,
+        filename: str,
+    ) -> CreateUserRequest:
+        data = cls.load_json(filename)
+
+        return CreateUserRequest(
+            **data,
+        )

pyrestkit/hooks/__init__.py

@@ -0,0 +1,5 @@
+from .hook_manager import HookManager
+
+__all__ = [
+    "HookManager",
+]

pyrestkit/hooks/hook.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+
+
+class Hook:
+    """
+    Base class for framework hooks.
+
+    Override only the callbacks you need.
+    """
+
+    def before_request(
+        self,
+        method: str,
+        url: str,
+        kwargs: dict[str, Any],
+    ) -> None:
+        return
+
+    def after_response(
+        self,
+        response: requests.Response,
+    ) -> None:
+        return

pyrestkit/hooks/hook_manager.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+
+from pyrestkit.hooks.hook import Hook
+
+
+class HookManager:
+    """
+    Executes registered hooks.
+    """
+
+    def __init__(
+        self,
+        hooks: list[Hook] | None = None,
+    ) -> None:
+        self._hooks = hooks or []
+
+    def before_request(
+        self,
+        method: str,
+        url: str,
+        kwargs: dict[str, Any],
+    ) -> None:
+        for hook in self._hooks:
+            hook.before_request(
+                method,
+                url,
+                kwargs,
+            )
+
+    def after_response(
+        self,
+        response: requests.Response,
+    ) -> None:
+        for hook in self._hooks:
+            hook.after_response(response)

pyrestkit/hooks/request_hook.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class RequestHook(ABC):
+    """
+    Executed before an HTTP request is sent.
+    """
+
+    @abstractmethod
+    def before_request(
+        self,
+        method: str,
+        url: str,
+        kwargs: dict[str, Any],
+    ) -> None: ...

pyrestkit/hooks/response_hook.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+import requests
+
+
+class ResponseHook(ABC):
+    """
+    Executed after an HTTP response is received.
+    """
+
+    @abstractmethod
+    def after_response(
+        self,
+        response: requests.Response,
+    ) -> None: ...

pyrestkit/hooks/timing_hook.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import requests
+
+from pyrestkit.hooks.hook import Hook
+
+
+class TimingHook(Hook):
+    """
+    Measures request execution time.
+    """
+
+    def __init__(self) -> None:
+        self._start = 0.0
+
+    def before_request(
+        self,
+        method: str,
+        url: str,
+        kwargs: dict[str, Any],
+    ) -> None:
+        self._start = time.perf_counter()
+
+    def after_response(
+        self,
+        response: requests.Response,
+    ) -> None:
+        elapsed = (time.perf_counter() - self._start) * 1000
+        print(f"Request completed in {elapsed:.2f} ms")

pyrestkit/models/__init__.py

@@ -0,0 +1,8 @@
+from .request import CreateUserRequest, UpdateUserRequest
+from .response import UserResponse
+
+__all__ = [
+    "CreateUserRequest",
+    "UpdateUserRequest",
+    "UserResponse",
+]

pyrestkit/models/base_response.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from typing import Any, Protocol, Self
+
+
+class BaseResponse(Protocol):
+    @classmethod
+    def from_dict(
+        cls,
+        data: dict[str, Any],
+    ) -> Self: ...

pyrestkit/models/request/__init__.py

@@ -0,0 +1,7 @@
+from .create_user_request import CreateUserRequest
+from .update_user_request import UpdateUserRequest
+
+__all__ = [
+    "CreateUserRequest",
+    "UpdateUserRequest",
+]

pyrestkit/models/request/create_user_request.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class CreateUserRequest:
+    """
+    Request model for creating a user.
+    """
+
+    name: str
+    job: str

pyrestkit/models/request/update_user_request.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class UpdateUserRequest:
+    """
+    Request model for updating a user.
+    """
+
+    job: str

pyrestkit/models/response/__init__.py

@@ -0,0 +1,5 @@
+from .user_response import UserResponse
+
+__all__ = [
+    "UserResponse",
+]

pyrestkit/models/response/create_user_response.py

@@ -0,0 +1,26 @@
+# from dataclasses import dataclass
+
+
+# @dataclass(slots=True)
+# class CreateUserResponse:
+#     id: str
+#     name: str
+#     job: str
+#     created_at: str
+
+#     @classmethod
+#     def from_dict(cls, data: dict) -> "CreateUserResponse":
+#         return cls(
+#             id=data["id"],
+#             name=data["name"],
+#             job=data["job"],
+#             created_at=data["createdAt"],
+#         )
+
+from dataclasses import dataclass
+
+from pyrestkit.models.base_response import BaseResponse
+
+
+@dataclass(slots=True)
+class CreateUserResponse(BaseResponse): ...

pyrestkit/models/response/get_user_response.py

@@ -0,0 +1,28 @@
+# from dataclasses import dataclass
+
+
+# @dataclass(slots=True)
+# class GetUserResponse:
+#     id: int
+#     email: str
+#     first_name: str
+#     last_name: str
+#     avatar: str
+
+#     @classmethod
+#     def from_dict(cls, data: dict) -> "GetUserResponse":
+#         return cls(
+#             id=data["id"],
+#             email=data["email"],
+#             first_name=data["first_name"],
+#             last_name=data["last_name"],
+#             avatar=data["avatar"],
+#         )
+
+from dataclasses import dataclass
+
+from pyrestkit.models.base_response import BaseResponse
+
+
+@dataclass(slots=True)
+class GetUserResponse(BaseResponse): ...