stackmate 0.1.0__tar.gz

stackmate-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sudhakar K
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

stackmate-0.1.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: stackmate
+Version: 0.1.0
+Summary: A Full-Stack Development Toolkit for Python developers.
+Author-email: Sudhakar K <sudhakark4227@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyJWT>=2.8.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# StackMate
+
+**StackMate** is a production-ready Full-Stack Development Toolkit for Python developers. It provides essential utilities for building robust APIs, managing authentication, handling errors, and simplifying database operations.
+
+## Features
+
+- **Logger**: Structured request/response logging with latency tracking.
+- **Validator**: API payload validation using type hints and schema checks.
+- **DB Helper**: Generic CRUD utilities for SQL/NoSQL databases.
+- **Auth**: Secure JWT token management (creation and verification).
+- **Error Handler**: Standardized API response formatting.
+- **Utils**: Common helper functions (UUIDs, timestamps, etc.).
+
+## Installation
+
+```bash
+pip install stackmate
+```
+
+## Quick Start
+
+```python
+from stackmate.logger import AppLogger
+from stackmate.auth import AuthManager
+
+# Initialize components
+logger = AppLogger("my-app")
+auth = AuthManager(secret_key="your-secret-key")
+
+# Use them in your application
+token = auth.create_token({"user_id": 123})
+```
+
+## Project Structure
+
+```text
+stackmate/
+├── stackmate/           # Core library files
+├── examples/            # Example usage scripts
+├── tests/               # Unit tests
+├── pyproject.toml       # Build configuration
+└── README.md            # Project documentation
+```
+
+## Author
+
+- **Sudhakar K** - [sudhakark4227@gmail.com](mailto:sudhakark4227@gmail.com)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

stackmate-0.1.0/README.md

@@ -0,0 +1,51 @@
+# StackMate
+
+**StackMate** is a production-ready Full-Stack Development Toolkit for Python developers. It provides essential utilities for building robust APIs, managing authentication, handling errors, and simplifying database operations.
+
+## Features
+
+- **Logger**: Structured request/response logging with latency tracking.
+- **Validator**: API payload validation using type hints and schema checks.
+- **DB Helper**: Generic CRUD utilities for SQL/NoSQL databases.
+- **Auth**: Secure JWT token management (creation and verification).
+- **Error Handler**: Standardized API response formatting.
+- **Utils**: Common helper functions (UUIDs, timestamps, etc.).
+
+## Installation
+
+```bash
+pip install stackmate
+```
+
+## Quick Start
+
+```python
+from stackmate.logger import AppLogger
+from stackmate.auth import AuthManager
+
+# Initialize components
+logger = AppLogger("my-app")
+auth = AuthManager(secret_key="your-secret-key")
+
+# Use them in your application
+token = auth.create_token({"user_id": 123})
+```
+
+## Project Structure
+
+```text
+stackmate/
+├── stackmate/           # Core library files
+├── examples/            # Example usage scripts
+├── tests/               # Unit tests
+├── pyproject.toml       # Build configuration
+└── README.md            # Project documentation
+```
+
+## Author
+
+- **Sudhakar K** - [sudhakark4227@gmail.com](mailto:sudhakark4227@gmail.com)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

stackmate-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stackmate"
+version = "0.1.0"
+authors = [
+  { name="Sudhakar K", email="sudhakark4227@gmail.com" },
+]
+description = "A Full-Stack Development Toolkit for Python developers."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "PyJWT>=2.8.0",
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "black>=23.0.0",
+    "isort>=5.12.0",
+    "mypy>=1.0.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["stackmate*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"

stackmate-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

stackmate-0.1.0/stackmate/__init__.py

@@ -0,0 +1,24 @@
+"""
+StackMate: A Full-Stack Development Toolkit for Python.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Sudhakar K"
+
+from stackmate.auth import AuthManager
+from stackmate.db_helper import DBHelper
+from stackmate.error_handler import APIResponse, ErrorCode
+from stackmate.logger import AppLogger
+from stackmate.utils import generate_uuid, get_timestamp
+from stackmate.validator import PayloadValidator
+
+__all__ = [
+    "AuthManager",
+    "DBHelper",
+    "APIResponse",
+    "ErrorCode",
+    "AppLogger",
+    "generate_uuid",
+    "get_timestamp",
+    "PayloadValidator",
+]

stackmate-0.1.0/stackmate/auth.py

@@ -0,0 +1,82 @@
+"""
+JWT and token management utilities for StackMate.
+"""
+
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, Optional, Union
+
+import jwt
+
+
+class AuthManager:
+    """
+    Manager for creating and verifying JWT tokens.
+    """
+
+    def __init__(
+        self,
+        secret_key: str,
+        algorithm: str = "HS256",
+        expires_delta: int = 60,
+    ):
+        """
+        Initializes the Auth Manager.
+
+        Args:
+            secret_key (str): Secret key for encoding/decoding.
+            algorithm (str): JWT algorithm. Defaults to HS256.
+            expires_delta (int): Expiry time in minutes. Defaults to 60.
+        """
+        self.secret_key = secret_key
+        self.algorithm = algorithm
+        self.expires_delta = expires_delta
+
+    def create_token(self, data: Dict[str, Any]) -> str:
+        """
+        Creates a JWT token.
+
+        Args:
+            data (Dict): The payload to include.
+
+        Returns:
+            str: Encoded JWT token.
+        """
+        to_encode = data.copy()
+        expire = datetime.now(timezone.utc) + timedelta(minutes=self.expires_delta)
+        to_encode.update({"exp": expire})
+        return jwt.encode(to_encode, self.secret_key, algorithm=self.algorithm)
+
+    def verify_token(self, token: str) -> Optional[Dict[str, Any]]:
+        """
+        Verifies and decodes a JWT token.
+
+        Args:
+            token (str): The JWT string.
+
+        Returns:
+            Optional[Dict]: The decoded payload if valid, None otherwise.
+        """
+        try:
+            return jwt.decode(token, self.secret_key, algorithms=[self.algorithm])
+        except (jwt.ExpiredSignatureError, jwt.InvalidTokenError):
+            return None
+
+    def decode_token(self, token: str) -> Optional[Dict[str, Any]]:
+        """
+        Decodes a token without verifying expiry (for debug/extraction).
+
+        Args:
+            token (str): The JWT string.
+
+        Returns:
+            Optional[Dict]: The decoded payload.
+        """
+        try:
+            return jwt.decode(
+                token,
+                self.secret_key,
+                algorithms=[self.algorithm],
+                options={"verify_exp": False},
+            )
+        except Exception:
+            return None

stackmate-0.1.0/stackmate/db_helper.py

@@ -0,0 +1,94 @@
+"""
+Database utility helpers for StackMate.
+Simulates a generic CRUD interface.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+
+class DBHelper:
+    """
+    Generic Database Helper for CRUD operations.
+    Acts as an abstraction layer (Mocked for demonstration).
+    """
+
+    def __init__(self, connection_string: str = "mock://localhost"):
+        """
+        Initializes the DB helper.
+
+        Args:
+            connection_string (str): Database connection URI.
+        """
+        self.connection_string = connection_string
+        # In a real app, you'd initialize a pool or client here
+        self._mock_db: List[Dict[str, Any]] = []
+
+    def create(self, table: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Inserts a new record into the "table".
+
+        Args:
+            table (str): Target table/collection name.
+            data (Dict): Record content.
+
+        Returns:
+            Dict: The created record.
+        """
+        # Mock implementation
+        record = {"id": len(self._mock_db) + 1, "table": table, **data}
+        self._mock_db.append(record)
+        return record
+
+    def read(self, table: str, filters: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
+        """
+        Retrieves records from the "table" based on filters.
+
+        Args:
+            table (str): Target table name.
+            filters (Dict): Query filters.
+
+        Returns:
+            List[Dict]: List of matching records.
+        """
+        results = [r for r in self._mock_db if r["table"] == table]
+        if filters:
+            for key, value in filters.items():
+                results = [r for r in results if r.get(key) == value]
+        return results
+
+    def update(
+        self, table: str, record_id: int, updates: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Updates an existing record.
+
+        Args:
+            table (str): Target table name.
+            record_id (int): ID of the record to update.
+            updates (Dict): Field-value updates.
+
+        Returns:
+            Optional[Dict]: The updated record if found.
+        """
+        for record in self._mock_db:
+            if record["table"] == table and record["id"] == record_id:
+                record.update(updates)
+                return record
+        return None
+
+    def delete(self, table: str, record_id: int) -> bool:
+        """
+        Deletes a record.
+
+        Args:
+            table (str): Target table name.
+            record_id (int): ID of the record.
+
+        Returns:
+            bool: True if deleted, False if not found.
+        """
+        for i, record in enumerate(self._mock_db):
+            if record["table"] == table and record["id"] == record_id:
+                del self._mock_db[i]
+                return True
+        return False

stackmate-0.1.0/stackmate/error_handler.py

@@ -0,0 +1,73 @@
+"""
+Unified error handling and structured API responses for StackMate.
+"""
+
+from enum import Enum
+from typing import Any, Dict, Optional, Union
+
+
+class ErrorCode(str, Enum):
+    """Enumeration of standard error codes."""
+
+    SUCCESS = "SUCCESS"
+    VALIDATION_ERROR = "VALIDATION_ERROR"
+    AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR"
+    NOT_FOUND = "NOT_FOUND"
+    DATABASE_ERROR = "DATABASE_ERROR"
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR"
+
+
+class APIResponse:
+    """Class to handle structured API responses."""
+
+    @staticmethod
+    def success(
+        data: Any = None,
+        message: str = "Operation successful",
+        status_code: int = 200,
+    ) -> Dict[str, Any]:
+        """
+        Generates a successful API response.
+
+        Args:
+            data (Any): The payload to return.
+            message (str): A message for the user.
+            status_code (int): HTTP status code.
+
+        Returns:
+            Dict[str, Any]: Structured success response.
+        """
+        return {
+            "success": True,
+            "message": message,
+            "data": data,
+            "error_code": ErrorCode.SUCCESS,
+            "status_code": status_code,
+        }
+
+    @staticmethod
+    def failure(
+        message: str,
+        error_code: ErrorCode = ErrorCode.INTERNAL_SERVER_ERROR,
+        data: Any = None,
+        status_code: int = 500,
+    ) -> Dict[str, Any]:
+        """
+        Generates a failed API response.
+
+        Args:
+            message (str): Error message.
+            error_code (ErrorCode): Standardized error code.
+            data (Any): Optional additional error context.
+            status_code (int): HTTP status code.
+
+        Returns:
+            Dict[str, Any]: Structured failure response.
+        """
+        return {
+            "success": False,
+            "message": message,
+            "data": data,
+            "error_code": error_code,
+            "status_code": status_code,
+        }

stackmate-0.1.0/stackmate/logger.py

@@ -0,0 +1,96 @@
+"""
+Request/Response logging utilities for StackMate.
+"""
+
+import json
+import logging
+import time
+from typing import Any, Dict, Optional
+
+from stackmate.utils import get_timestamp, parse_latency
+
+
+class AppLogger:
+    """
+    Standard logger for API requests and responses.
+    """
+
+    def __init__(self, name: str = "StackMate", level: int = logging.INFO):
+        """
+        Initializes the logger.
+
+        Args:
+            name (str): Name of the logger.
+            level (int): Logging level.
+        """
+        self.logger = logging.getLogger(name)
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        handler.setFormatter(formatter)
+        if not self.logger.handlers:
+            self.logger.addHandler(handler)
+        self.logger.setLevel(level)
+
+    def log_request(self, method: str, url: str, payload: Optional[Dict[str, Any]] = None) -> float:
+        """
+        Logs an incoming API request.
+
+        Args:
+            method (str): HTTP method (GET, POST, etc.).
+            url (str): Target URL.
+            payload (Dict): Request body.
+
+        Returns:
+            float: The start time of the request.
+        """
+        start_time = time.time()
+        log_data = {
+            "timestamp": get_timestamp(),
+            "type": "REQUEST",
+            "method": method,
+            "url": url,
+            "payload": payload,
+        }
+        self.logger.info("Request: %s", json.dumps(log_data))
+        return start_time
+
+    def log_response(
+        self,
+        method: str,
+        url: str,
+        status_code: int,
+        start_time: float,
+        response_data: Optional[Any] = None,
+    ) -> None:
+        """
+        Logs an API response with latency calculation.
+
+        Args:
+            method (str): HTTP method.
+            url (str): Target URL.
+            status_code (int): HTTP status code.
+            start_time (float): The timestamp when the request started.
+            response_data (Any): The response content.
+        """
+        end_time = time.time()
+        latency = parse_latency(start_time, end_time)
+        log_data = {
+            "timestamp": get_timestamp(),
+            "type": "RESPONSE",
+            "method": method,
+            "url": url,
+            "status": status_code,
+            "latency": latency,
+            "data": response_data,
+        }
+        self.logger.info("Response: %s", json.dumps(log_data))
+
+    def error(self, message: str, exc_info: bool = True) -> None:
+        """Logs an error message."""
+        self.logger.error(message, exc_info=exc_info)
+
+    def info(self, message: str) -> None:
+        """Logs an info message."""
+        self.logger.info(message)

stackmate-0.1.0/stackmate/utils.py

@@ -0,0 +1,62 @@
+"""
+Miscellaneous helper functions for StackMate.
+"""
+
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+
+def generate_uuid() -> str:
+    """
+    Generates a unique UUID v4 string.
+
+    Returns:
+        str: A unique UUID.
+    """
+    return str(uuid.uuid4())
+
+
+def get_timestamp(utc: bool = True) -> str:
+    """
+    Returns the current timestamp in ISO format.
+
+    Args:
+        utc (bool): Whether to use UTC time. Defaults to True.
+
+    Returns:
+        str: ISO formatted timestamp.
+    """
+    if utc:
+        return datetime.now(timezone.utc).isoformat()
+    return datetime.now().isoformat()
+
+
+def format_response_data(data: Any) -> Dict[str, Any]:
+    """
+    Helper to ensure data is in a dictionary format for JSON responses.
+
+    Args:
+        data (Any): Input data.
+
+    Returns:
+        Dict[str, Any]: Formatted data.
+    """
+    if isinstance(data, dict):
+        return data
+    return {"result": data}
+
+
+def parse_latency(start_time: float, end_time: float) -> str:
+    """
+    Calculates latency and returns it as a formatted string.
+
+    Args:
+        start_time (float): Execution start time.
+        end_time (float): Execution end time.
+
+    Returns:
+        str: Latency in milliseconds (e.g., "120ms").
+    """
+    duration = (end_time - start_time) * 1000
+    return f"{duration:.2f}ms"

stackmate-0.1.0/stackmate/validator.py

@@ -0,0 +1,66 @@
+"""
+API payload validation utilities for StackMate.
+"""
+
+from typing import Any, Dict, List, Optional, Type, Union
+
+
+class PayloadValidator:
+    """
+    Validates API request payloads against required fields and types.
+    """
+
+    @staticmethod
+    def validate(
+        payload: Dict[str, Any],
+        schema: Dict[str, Type],
+        required_fields: Optional[List[str]] = None,
+    ) -> List[str]:
+        """
+        Validates the payload against a schema.
+
+        Args:
+            payload (Dict): The data to validate.
+            schema (Dict): A mapping of field names to expected types.
+            required_fields (List): A list of fields that must be present.
+
+        Returns:
+            List[str]: A list of error messages. Empty if valid.
+        """
+        errors = []
+        required = required_fields or []
+
+        # Check for missing required fields
+        for field in required:
+            if field not in payload:
+                errors.append(f"Field '{field}' is required.")
+
+        # Check types for present fields
+        for field, value in payload.items():
+            if field in schema:
+                expected_type = schema[field]
+                if not isinstance(value, expected_type):
+                    errors.append(
+                        f"Field '{field}' must be of type {expected_type.__name__}, "
+                        f"got {type(value).__name__}."
+                    )
+            elif field not in schema and required_fields is not None:
+                # Optionally handle unexpected fields if schema is strict
+                # For now, we allow them unless we want strict validation
+                pass
+
+        return errors
+
+    @staticmethod
+    def is_valid(
+        payload: Dict[str, Any],
+        schema: Dict[str, Type],
+        required_fields: Optional[List[str]] = None,
+    ) -> bool:
+        """
+        Shortcut to check if a payload is valid.
+
+        Returns:
+            bool: True if valid, False otherwise.
+        """
+        return len(PayloadValidator.validate(payload, schema, required_fields)) == 0

stackmate-0.1.0/stackmate.egg-info/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: stackmate
+Version: 0.1.0
+Summary: A Full-Stack Development Toolkit for Python developers.
+Author-email: Sudhakar K <sudhakark4227@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyJWT>=2.8.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# StackMate
+
+**StackMate** is a production-ready Full-Stack Development Toolkit for Python developers. It provides essential utilities for building robust APIs, managing authentication, handling errors, and simplifying database operations.
+
+## Features
+
+- **Logger**: Structured request/response logging with latency tracking.
+- **Validator**: API payload validation using type hints and schema checks.
+- **DB Helper**: Generic CRUD utilities for SQL/NoSQL databases.
+- **Auth**: Secure JWT token management (creation and verification).
+- **Error Handler**: Standardized API response formatting.
+- **Utils**: Common helper functions (UUIDs, timestamps, etc.).
+
+## Installation
+
+```bash
+pip install stackmate
+```
+
+## Quick Start
+
+```python
+from stackmate.logger import AppLogger
+from stackmate.auth import AuthManager
+
+# Initialize components
+logger = AppLogger("my-app")
+auth = AuthManager(secret_key="your-secret-key")
+
+# Use them in your application
+token = auth.create_token({"user_id": 123})
+```
+
+## Project Structure
+
+```text
+stackmate/
+├── stackmate/           # Core library files
+├── examples/            # Example usage scripts
+├── tests/               # Unit tests
+├── pyproject.toml       # Build configuration
+└── README.md            # Project documentation
+```
+
+## Author
+
+- **Sudhakar K** - [sudhakark4227@gmail.com](mailto:sudhakark4227@gmail.com)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

stackmate-0.1.0/stackmate.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+stackmate/__init__.py
+stackmate/auth.py
+stackmate/db_helper.py
+stackmate/error_handler.py
+stackmate/logger.py
+stackmate/utils.py
+stackmate/validator.py
+stackmate.egg-info/PKG-INFO
+stackmate.egg-info/SOURCES.txt
+stackmate.egg-info/dependency_links.txt
+stackmate.egg-info/requires.txt
+stackmate.egg-info/top_level.txt
+tests/test_auth.py
+tests/test_db_helper.py
+tests/test_error_handler.py
+tests/test_logger.py
+tests/test_utils.py
+tests/test_validator.py

stackmate-0.1.0/stackmate.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

stackmate-0.1.0/stackmate.egg-info/requires.txt

@@ -0,0 +1,9 @@
+PyJWT>=2.8.0
+pydantic>=2.0.0
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+black>=23.0.0
+isort>=5.12.0
+mypy>=1.0.0

stackmate-0.1.0/stackmate.egg-info/top_level.txt

@@ -0,0 +1 @@
+stackmate

stackmate-0.1.0/tests/test_auth.py

@@ -0,0 +1,69 @@
+"""
+Unit tests for stackmate.auth module.
+"""
+
+import time
+
+import jwt
+import pytest
+from stackmate.auth import AuthManager
+
+
+def test_auth_manager_initialization():
+    """Test AuthManager initializes correctly."""
+    auth = AuthManager(secret_key="test-secret")
+    assert auth.secret_key == "test-secret"
+    assert auth.algorithm == "HS256"
+    assert auth.expires_delta == 60
+
+
+def test_create_token():
+    """Test JWT token creation."""
+    auth = AuthManager(secret_key="test-secret")
+    token = auth.create_token({"user_id": 123})
+    assert isinstance(token, str)
+    assert len(token) > 0
+
+
+def test_verify_valid_token():
+    """Test verifying a valid token."""
+    auth = AuthManager(secret_key="test-secret")
+    token = auth.create_token({"user_id": 123, "role": "admin"})
+    decoded = auth.verify_token(token)
+    assert decoded is not None
+    assert decoded["user_id"] == 123
+    assert decoded["role"] == "admin"
+
+
+def test_verify_invalid_token():
+    """Test verifying an invalid token."""
+    auth = AuthManager(secret_key="test-secret")
+    decoded = auth.verify_token("invalid.token.here")
+    assert decoded is None
+
+
+def test_verify_token_wrong_secret():
+    """Test verifying a token with wrong secret key."""
+    auth1 = AuthManager(secret_key="secret1")
+    auth2 = AuthManager(secret_key="secret2")
+    token = auth1.create_token({"user_id": 123})
+    decoded = auth2.verify_token(token)
+    assert decoded is None
+
+
+def test_decode_token_without_verification():
+    """Test decoding token without expiry verification."""
+    auth = AuthManager(secret_key="test-secret", expires_delta=0)
+    token = auth.create_token({"user_id": 123})
+    time.sleep(1)
+    decoded = auth.decode_token(token)
+    assert decoded is not None
+    assert decoded["user_id"] == 123
+
+
+def test_token_contains_expiry():
+    """Test that created token contains expiry claim."""
+    auth = AuthManager(secret_key="test-secret")
+    token = auth.create_token({"user_id": 123})
+    decoded = auth.decode_token(token)
+    assert "exp" in decoded

stackmate-0.1.0/tests/test_db_helper.py

@@ -0,0 +1,73 @@
+"""
+Unit tests for stackmate.db_helper module.
+"""
+
+import pytest
+from stackmate.db_helper import DBHelper
+
+
+def test_db_helper_initialization():
+    """Test DBHelper initializes correctly."""
+    db = DBHelper("sqlite:///:memory:")
+    assert db.connection_string == "sqlite:///:memory:"
+    assert db._mock_db == []
+
+
+def test_create_record():
+    """Test creating a new record."""
+    db = DBHelper()
+    record = db.create("users", {"username": "john", "email": "john@example.com"})
+    assert record["id"] == 1
+    assert record["table"] == "users"
+    assert record["username"] == "john"
+
+
+def test_read_all_records():
+    """Test reading all records from a table."""
+    db = DBHelper()
+    db.create("users", {"username": "john"})
+    db.create("users", {"username": "jane"})
+    records = db.read("users")
+    assert len(records) == 2
+
+
+def test_read_with_filters():
+    """Test reading records with filters."""
+    db = DBHelper()
+    db.create("users", {"username": "john", "role": "admin"})
+    db.create("users", {"username": "jane", "role": "user"})
+    records = db.read("users", filters={"role": "admin"})
+    assert len(records) == 1
+    assert records[0]["username"] == "john"
+
+
+def test_update_record():
+    """Test updating an existing record."""
+    db = DBHelper()
+    record = db.create("users", {"username": "john"})
+    updated = db.update("users", record["id"], {"username": "john_updated"})
+    assert updated is not None
+    assert updated["username"] == "john_updated"
+
+
+def test_update_nonexistent_record():
+    """Test updating a record that doesn't exist."""
+    db = DBHelper()
+    result = db.update("users", 999, {"username": "ghost"})
+    assert result is None
+
+
+def test_delete_record():
+    """Test deleting a record."""
+    db = DBHelper()
+    record = db.create("users", {"username": "john"})
+    deleted = db.delete("users", record["id"])
+    assert deleted is True
+    assert len(db.read("users")) == 0
+
+
+def test_delete_nonexistent_record():
+    """Test deleting a record that doesn't exist."""
+    db = DBHelper()
+    deleted = db.delete("users", 999)
+    assert deleted is False

stackmate-0.1.0/tests/test_error_handler.py

@@ -0,0 +1,71 @@
+"""
+Unit tests for stackmate.error_handler module.
+"""
+
+import pytest
+from stackmate.error_handler import APIResponse, ErrorCode
+
+
+def test_success_response_default():
+    """Test success response with default values."""
+    response = APIResponse.success()
+    assert response["success"] is True
+    assert response["message"] == "Operation successful"
+    assert response["error_code"] == ErrorCode.SUCCESS
+    assert response["status_code"] == 200
+
+
+def test_success_response_with_data():
+    """Test success response with custom data."""
+    data = {"user_id": 123}
+    response = APIResponse.success(data=data, message="User created")
+    assert response["success"] is True
+    assert response["data"] == data
+    assert response["message"] == "User created"
+
+
+def test_success_response_custom_status():
+    """Test success response with custom status code."""
+    response = APIResponse.success(status_code=201)
+    assert response["status_code"] == 201
+
+
+def test_failure_response_default():
+    """Test failure response with default values."""
+    response = APIResponse.failure(message="Something went wrong")
+    assert response["success"] is False
+    assert response["message"] == "Something went wrong"
+    assert response["error_code"] == ErrorCode.INTERNAL_SERVER_ERROR
+    assert response["status_code"] == 500
+
+
+def test_failure_response_validation_error():
+    """Test failure response with validation error."""
+    response = APIResponse.failure(
+        message="Invalid input",
+        error_code=ErrorCode.VALIDATION_ERROR,
+        status_code=400,
+    )
+    assert response["success"] is False
+    assert response["error_code"] == ErrorCode.VALIDATION_ERROR
+    assert response["status_code"] == 400
+
+
+def test_failure_response_with_data():
+    """Test failure response with additional error data."""
+    error_data = {"field": "email", "issue": "invalid format"}
+    response = APIResponse.failure(
+        message="Validation failed",
+        error_code=ErrorCode.VALIDATION_ERROR,
+        data=error_data,
+    )
+    assert response["data"] == error_data
+
+
+def test_error_code_enum_values():
+    """Test ErrorCode enum contains expected values."""
+    assert ErrorCode.SUCCESS == "SUCCESS"
+    assert ErrorCode.VALIDATION_ERROR == "VALIDATION_ERROR"
+    assert ErrorCode.AUTHENTICATION_ERROR == "AUTHENTICATION_ERROR"
+    assert ErrorCode.NOT_FOUND == "NOT_FOUND"
+    assert ErrorCode.DATABASE_ERROR == "DATABASE_ERROR"

stackmate-0.1.0/tests/test_logger.py

@@ -0,0 +1,58 @@
+"""
+Unit tests for stackmate.logger module.
+"""
+
+import logging
+import time
+
+import pytest
+from stackmate.logger import AppLogger
+
+
+def test_logger_initialization():
+    """Test logger is initialized correctly."""
+    logger = AppLogger("TestApp")
+    assert logger.logger.name == "TestApp"
+    assert logger.logger.level == logging.INFO
+
+
+def test_logger_custom_level():
+    """Test logger with custom logging level."""
+    logger = AppLogger("DebugApp", level=logging.DEBUG)
+    assert logger.logger.level == logging.DEBUG
+
+
+def test_log_request_returns_timestamp():
+    """Test log_request returns a start time."""
+    logger = AppLogger("RequestTest")
+    start_time = logger.log_request("GET", "/api/users")
+    assert isinstance(start_time, float)
+    assert start_time > 0
+
+
+def test_log_request_with_payload():
+    """Test log_request with payload data."""
+    logger = AppLogger("PayloadTest")
+    payload = {"username": "test", "email": "test@example.com"}
+    start_time = logger.log_request("POST", "/api/users", payload=payload)
+    assert isinstance(start_time, float)
+
+
+def test_log_response():
+    """Test log_response logs correctly."""
+    logger = AppLogger("ResponseTest")
+    start_time = time.time()
+    time.sleep(0.01)
+    logger.log_response("GET", "/api/users", 200, start_time, {"users": []})
+
+
+def test_logger_info_method():
+    """Test info logging method."""
+    logger = AppLogger("InfoTest")
+    logger.info("This is an info message")
+
+
+def test_logger_error_method():
+    """Test error logging method."""
+    logger = AppLogger("ErrorTest")
+    logger.error("This is an error message", exc_info=False)

stackmate-0.1.0/tests/test_utils.py

@@ -0,0 +1,59 @@
+"""
+Unit tests for stackmate.utils module.
+"""
+
+import pytest
+from stackmate.utils import (
+    format_response_data,
+    generate_uuid,
+    get_timestamp,
+    parse_latency,
+)
+
+
+def test_generate_uuid():
+    """Test UUID generation returns a valid UUID string."""
+    uuid1 = generate_uuid()
+    uuid2 = generate_uuid()
+    assert isinstance(uuid1, str)
+    assert len(uuid1) == 36
+    assert uuid1 != uuid2
+
+
+def test_get_timestamp_utc():
+    """Test UTC timestamp generation."""
+    timestamp = get_timestamp(utc=True)
+    assert isinstance(timestamp, str)
+    assert "T" in timestamp
+    assert "+" in timestamp or "Z" in timestamp
+
+
+def test_get_timestamp_local():
+    """Test local timestamp generation."""
+    timestamp = get_timestamp(utc=False)
+    assert isinstance(timestamp, str)
+    assert "T" in timestamp
+
+
+def test_format_response_data_dict():
+    """Test formatting when data is already a dict."""
+    data = {"key": "value"}
+    result = format_response_data(data)
+    assert result == data
+
+
+def test_format_response_data_non_dict():
+    """Test formatting when data is not a dict."""
+    data = "simple string"
+    result = format_response_data(data)
+    assert result == {"result": data}
+
+
+def test_parse_latency():
+    """Test latency calculation."""
+    start = 1.0
+    end = 1.12
+    latency = parse_latency(start, end)
+    assert isinstance(latency, str)
+    assert "ms" in latency
+    assert "120.00ms" == latency

stackmate-0.1.0/tests/test_validator.py

@@ -0,0 +1,64 @@
+"""
+Unit tests for stackmate.validator module.
+"""
+
+import pytest
+from stackmate.validator import PayloadValidator
+
+
+def test_validate_success():
+    """Test validation passes with correct payload."""
+    payload = {"username": "john", "age": 30}
+    schema = {"username": str, "age": int}
+    errors = PayloadValidator.validate(payload, schema, required_fields=["username", "age"])
+    assert errors == []
+
+
+def test_validate_missing_required_field():
+    """Test validation fails when required field is missing."""
+    payload = {"username": "john"}
+    schema = {"username": str, "age": int}
+    errors = PayloadValidator.validate(payload, schema, required_fields=["username", "age"])
+    assert len(errors) == 1
+    assert "age" in errors[0]
+    assert "required" in errors[0]
+
+
+def test_validate_wrong_type():
+    """Test validation fails when field has wrong type."""
+    payload = {"username": "john", "age": "thirty"}
+    schema = {"username": str, "age": int}
+    errors = PayloadValidator.validate(payload, schema, required_fields=["username", "age"])
+    assert len(errors) == 1
+    assert "age" in errors[0]
+    assert "int" in errors[0]
+
+
+def test_validate_multiple_errors():
+    """Test validation returns multiple errors."""
+    payload = {"age": "thirty"}
+    schema = {"username": str, "age": int}
+    errors = PayloadValidator.validate(payload, schema, required_fields=["username", "age"])
+    assert len(errors) == 2
+
+
+def test_is_valid_true():
+    """Test is_valid returns True for valid payload."""
+    payload = {"username": "john", "email": "john@example.com"}
+    schema = {"username": str, "email": str}
+    assert PayloadValidator.is_valid(payload, schema, required_fields=["username"]) is True
+
+
+def test_is_valid_false():
+    """Test is_valid returns False for invalid payload."""
+    payload = {"username": 123}
+    schema = {"username": str}
+    assert PayloadValidator.is_valid(payload, schema, required_fields=["username"]) is False
+
+
+def test_validate_optional_fields():
+    """Test validation allows optional fields."""
+    payload = {"username": "john"}
+    schema = {"username": str, "age": int}
+    errors = PayloadValidator.validate(payload, schema, required_fields=["username"])
+    assert errors == []